feat(entity): 添加接待人相关字段

- 新增receptionistId字段，记录接待人用户ID
- 新增receptionistName字段，记录接待人名称
- 字段均添加了相应的Schema描述信息feat(entity): 新增接待人用户ID及名称字段

- 在ShopDealerApply实体中添加receptionistId字段表示接待人用户ID
- 添加receptionistName字段用于存储接待人名称
- 对新增字段增加Swagger注解描述信息
- 保持原有房号和佣金比例字段不变

.gitignore

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

README.md

@@ -284,3 +284,5 @@ docker run -d -p 9200:9200 websoft-api
 ---
 
 ⭐ 如果这个项目对您有帮助，请给我们一个星标！
+
+

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/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/ai/后端实现指南.md

@@ -0,0 +1,459 @@
+# 客户跟进7步骤后端实现指南
+
+## 📋 概述
+
+本指南详细说明如何实现客户跟进7个步骤功能的后端代码，包括数据库设计、Java后端实现和API接口。
+
+## 🗄️ 数据库设计
+
+### 1. 修改 credit_mp_customer 表结构
+
+```sql
+-- 为第5-7步添加字段（第1-4步基础字段已存在；如未包含审核时间/审核人字段，请先补齐 step1-4 的 approved_at/approved_by）
+-- 参考：docs/sql/credit_mp_customer_step1_4_approval_columns.sql
+-- 第5步：合同签订
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step5_submitted TINYINT DEFAULT 0 COMMENT '是否已提交';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step5_submitted_at VARCHAR(255) COMMENT '提交时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step5_contracts TEXT COMMENT '合同信息JSON数组';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step5_need_approval TINYINT DEFAULT 1 COMMENT '是否需要审核';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step5_approved TINYINT DEFAULT 0 COMMENT '是否审核通过';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step5_approved_at VARCHAR(255) COMMENT '审核时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step5_approved_by BIGINT COMMENT '审核人ID';
+
+-- 第6步：订单回款
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_submitted TINYINT DEFAULT 0 COMMENT '是否已提交';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_submitted_at VARCHAR(255) COMMENT '提交时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_payment_records TEXT COMMENT '财务录入的回款记录JSON数组';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_expected_payments TEXT COMMENT '预计回款JSON数组';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_need_approval TINYINT DEFAULT 1 COMMENT '是否需要审核';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_approved TINYINT DEFAULT 0 COMMENT '是否审核通过';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_approved_at VARCHAR(255) COMMENT '审核时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step6_approved_by BIGINT COMMENT '审核人ID';
+
+-- 第7步：电话回访
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step7_submitted TINYINT DEFAULT 0 COMMENT '是否已提交';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step7_submitted_at VARCHAR(255) COMMENT '提交时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step7_visit_records TEXT COMMENT '回访记录JSON数组';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step7_need_approval TINYINT DEFAULT 1 COMMENT '是否需要审核';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step7_approved TINYINT DEFAULT 0 COMMENT '是否审核通过';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step7_approved_at VARCHAR(255) COMMENT '审核时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step7_approved_by BIGINT COMMENT '审核人ID';
+
+-- 添加流程结束相关字段
+ALTER TABLE credit_mp_customer ADD COLUMN follow_process_ended TINYINT DEFAULT 0 COMMENT '流程是否已结束';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_process_end_time VARCHAR(255) COMMENT '流程结束时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_process_end_reason TEXT COMMENT '流程结束原因';
+```
+
+### 2. 创建审核记录表（可选）
+
+```sql
+CREATE TABLE credit_follow_approval (
+  id BIGINT PRIMARY KEY AUTO_INCREMENT,
+  customer_id BIGINT NOT NULL COMMENT '客户ID',
+  step TINYINT NOT NULL COMMENT '步骤号',
+  approved TINYINT NOT NULL COMMENT '是否通过',
+  remark TEXT COMMENT '审核备注',
+  approved_by BIGINT COMMENT '审核人ID',
+  approved_at VARCHAR(255) COMMENT '审核时间',
+  created_at VARCHAR(255) COMMENT '创建时间',
+  INDEX idx_customer_step (customer_id, step),
+  INDEX idx_approved_by (approved_by)
+) COMMENT='跟进步骤审核记录';
+```
+
+## ☕ Java后端实现
+
+### 1. 实体类修改
+
+```java
+// CreditMpCustomer.java 添加字段
+public class CreditMpCustomer {
+    // ... 现有字段
+    
+    // 第5步字段
+    private Integer followStep5Submitted;
+    private String followStep5SubmittedAt;
+    private String followStep5Contracts;
+    private Integer followStep5NeedApproval;
+    private Integer followStep5Approved;
+    private String followStep5ApprovedAt;
+    private Long followStep5ApprovedBy;
+    
+    // 第6步字段
+    private Integer followStep6Submitted;
+    private String followStep6SubmittedAt;
+    private String followStep6PaymentRecords;
+    private String followStep6ExpectedPayments;
+    private Integer followStep6NeedApproval;
+    private Integer followStep6Approved;
+    private String followStep6ApprovedAt;
+    private Long followStep6ApprovedBy;
+    
+    // 第7步字段
+    private Integer followStep7Submitted;
+    private String followStep7SubmittedAt;
+    private String followStep7VisitRecords;
+    private Integer followStep7NeedApproval;
+    private Integer followStep7Approved;
+    private String followStep7ApprovedAt;
+    private Long followStep7ApprovedBy;
+    
+    // 流程结束字段
+    private Integer followProcessEnded;
+    private String followProcessEndTime;
+    private String followProcessEndReason;
+    
+    // getter/setter 方法...
+}
+```
+
+### 2. DTO类创建
+
+```java
+// FollowStepApprovalDTO.java
+@Data
+public class FollowStepApprovalDTO {
+    private Long customerId;
+    private Integer step;
+    private Boolean approved;
+    private String remark;
+}
+
+// BatchFollowStepApprovalDTO.java
+@Data
+public class BatchFollowStepApprovalDTO {
+    private List<FollowStepApprovalDTO> approvals;
+}
+
+// FollowStatisticsDTO.java
+@Data
+public class FollowStatisticsDTO {
+    private Integer totalSteps;
+    private Integer completedSteps;
+    private Integer currentStep;
+    private Double progress;
+    private List<FollowStepDetailDTO> stepDetails;
+}
+
+// FollowStepDetailDTO.java
+@Data
+public class FollowStepDetailDTO {
+    private Integer step;
+    private String title;
+    private String status; // pending, submitted, approved, rejected
+    private String submittedAt;
+    private String approvedAt;
+}
+```
+
+### 3. Service层实现
+
+```java
+// CreditMpCustomerServiceImpl.java 添加方法
+
+@Service
+public class CreditMpCustomerServiceImpl implements CreditMpCustomerService {
+    
+    /**
+     * 审核跟进步骤
+     */
+    @Override
+    @Transactional
+    public void approveFollowStep(FollowStepApprovalDTO dto) {
+        CreditMpCustomer customer = getById(dto.getCustomerId());
+        if (customer == null) {
+            throw new ServiceException("客户不存在");
+        }
+        
+        // 验证步骤是否已提交
+        if (!isStepSubmitted(customer, dto.getStep())) {
+            throw new ServiceException("该步骤尚未提交，无法审核");
+        }
+        
+        // 更新审核状态
+        updateStepApproval(customer, dto);
+        
+        // 记录审核日志
+        saveApprovalLog(dto);
+        
+        // 如果审核通过，更新客户步骤状态
+        if (dto.getApproved()) {
+            updateCustomerStep(customer, dto.getStep());
+        }
+    }
+    
+    /**
+     * 批量审核跟进步骤
+     */
+    @Override
+    @Transactional
+    public void batchApproveFollowSteps(BatchFollowStepApprovalDTO dto) {
+        for (FollowStepApprovalDTO approval : dto.getApprovals()) {
+            approveFollowStep(approval);
+        }
+    }
+    
+    /**
+     * 获取待审核的跟进步骤列表
+     */
+    @Override
+    public List<PendingApprovalStepVO> getPendingApprovalSteps(FollowStepQueryDTO query) {
+        return baseMapper.selectPendingApprovalSteps(query);
+    }
+    
+    /**
+     * 获取客户跟进统计
+     */
+    @Override
+    public FollowStatisticsDTO getFollowStatistics(Long customerId) {
+        CreditMpCustomer customer = getById(customerId);
+        if (customer == null) {
+            throw new ServiceException("客户不存在");
+        }
+        
+        FollowStatisticsDTO statistics = new FollowStatisticsDTO();
+        statistics.setTotalSteps(7);
+        
+        List<FollowStepDetailDTO> stepDetails = new ArrayList<>();
+        int completedSteps = 0;
+        int currentStep = 1;
+        
+        for (int i = 1; i <= 7; i++) {
+            FollowStepDetailDTO detail = getStepDetail(customer, i);
+            stepDetails.add(detail);
+            
+            if ("approved".equals(detail.getStatus())) {
+                completedSteps++;
+                currentStep = i + 1;
+            } else if ("submitted".equals(detail.getStatus()) && currentStep == 1) {
+                currentStep = i;
+            }
+        }
+        
+        statistics.setCompletedSteps(completedSteps);
+        statistics.setCurrentStep(Math.min(currentStep, 7));
+        statistics.setProgress((double) completedSteps / 7 * 100);
+        statistics.setStepDetails(stepDetails);
+        
+        return statistics;
+    }
+    
+    /**
+     * 结束客户跟进流程
+     */
+    @Override
+    @Transactional
+    public void endFollowProcess(Long customerId, String reason) {
+        CreditMpCustomer customer = getById(customerId);
+        if (customer == null) {
+            throw new ServiceException("客户不存在");
+        }
+        
+        customer.setFollowProcessEnded(1);
+        customer.setFollowProcessEndTime(DateUtil.formatDateTime(new Date()));
+        customer.setFollowProcessEndReason(reason);
+        
+        updateById(customer);
+    }
+    
+    // 私有辅助方法...
+    private boolean isStepSubmitted(CreditMpCustomer customer, Integer step) {
+        switch (step) {
+            case 1: return customer.getFollowStep1Submitted() == 1;
+            case 2: return customer.getFollowStep2Submitted() == 1;
+            // ... 其他步骤
+            case 7: return customer.getFollowStep7Submitted() == 1;
+            default: return false;
+        }
+    }
+    
+    private void updateStepApproval(CreditMpCustomer customer, FollowStepApprovalDTO dto) {
+        String currentTime = DateUtil.formatDateTime(new Date());
+        Long currentUserId = SecurityFrameworkUtils.getLoginUserId();
+        
+        switch (dto.getStep()) {
+            case 5:
+                customer.setFollowStep5Approved(dto.getApproved() ? 1 : 0);
+                customer.setFollowStep5ApprovedAt(currentTime);
+                customer.setFollowStep5ApprovedBy(currentUserId);
+                break;
+            case 6:
+                customer.setFollowStep6Approved(dto.getApproved() ? 1 : 0);
+                customer.setFollowStep6ApprovedAt(currentTime);
+                customer.setFollowStep6ApprovedBy(currentUserId);
+                break;
+            case 7:
+                customer.setFollowStep7Approved(dto.getApproved() ? 1 : 0);
+                customer.setFollowStep7ApprovedAt(currentTime);
+                customer.setFollowStep7ApprovedBy(currentUserId);
+                break;
+        }
+        
+        updateById(customer);
+    }
+}
+```
+
+### 4. Controller层实现
+
+```java
+// CreditMpCustomerController.java 添加接口
+
+@RestController
+@RequestMapping("/credit/credit-mp-customer")
+public class CreditMpCustomerController {
+    
+    @PostMapping("/approve-follow-step")
+    @OperLog(title = "审核跟进步骤", businessType = BusinessType.UPDATE)
+    public R<Void> approveFollowStep(@RequestBody FollowStepApprovalDTO dto) {
+        creditMpCustomerService.approveFollowStep(dto);
+        return R.ok();
+    }
+    
+    @PostMapping("/batch-approve-follow-steps")
+    @OperLog(title = "批量审核跟进步骤", businessType = BusinessType.UPDATE)
+    public R<Void> batchApproveFollowSteps(@RequestBody BatchFollowStepApprovalDTO dto) {
+        creditMpCustomerService.batchApproveFollowSteps(dto);
+        return R.ok();
+    }
+    
+    @GetMapping("/pending-approval-steps")
+    @OperLog(title = "获取待审核跟进步骤", businessType = BusinessType.SELECT)
+    public R<List<PendingApprovalStepVO>> getPendingApprovalSteps(FollowStepQueryDTO query) {
+        List<PendingApprovalStepVO> list = creditMpCustomerService.getPendingApprovalSteps(query);
+        return R.ok(list);
+    }
+    
+    @GetMapping("/follow-statistics/{customerId}")
+    @OperLog(title = "获取客户跟进统计", businessType = BusinessType.SELECT)
+    public R<FollowStatisticsDTO> getFollowStatistics(@PathVariable Long customerId) {
+        FollowStatisticsDTO statistics = creditMpCustomerService.getFollowStatistics(customerId);
+        return R.ok(statistics);
+    }
+    
+    @PostMapping("/end-follow-process")
+    @OperLog(title = "结束客户跟进流程", businessType = BusinessType.UPDATE)
+    public R<Void> endFollowProcess(@RequestBody EndFollowProcessDTO dto) {
+        creditMpCustomerService.endFollowProcess(dto.getCustomerId(), dto.getReason());
+        return R.ok();
+    }
+}
+```
+
+### 5. Mapper层SQL
+
+```xml
+<!-- CreditMpCustomerMapper.xml 添加查询方法 -->
+
+<select id="selectPendingApprovalSteps" resultType="com.your.package.PendingApprovalStepVO">
+    SELECT 
+        c.id as customerId,
+        c.to_user as customerName,
+        5 as step,
+        '合同签订' as stepTitle,
+        c.follow_step5_submitted_at as submittedAt,
+        u.real_name as submittedBy,
+        c.follow_step5_contracts as content
+    FROM credit_mp_customer c
+    LEFT JOIN sys_user u ON c.user_id = u.user_id
+    WHERE c.follow_step5_submitted = 1 
+    AND c.follow_step5_approved = 0 
+    AND c.deleted = 0
+    
+    UNION ALL
+    
+    SELECT 
+        c.id as customerId,
+        c.to_user as customerName,
+        6 as step,
+        '订单回款' as stepTitle,
+        c.follow_step6_submitted_at as submittedAt,
+        u.real_name as submittedBy,
+        c.follow_step6_expected_payments as content
+    FROM credit_mp_customer c
+    LEFT JOIN sys_user u ON c.user_id = u.user_id
+    WHERE c.follow_step6_submitted = 1 
+    AND c.follow_step6_approved = 0 
+    AND c.deleted = 0
+    
+    UNION ALL
+    
+    SELECT 
+        c.id as customerId,
+        c.to_user as customerName,
+        7 as step,
+        '电话回访' as stepTitle,
+        c.follow_step7_submitted_at as submittedAt,
+        u.real_name as submittedBy,
+        c.follow_step7_visit_records as content
+    FROM credit_mp_customer c
+    LEFT JOIN sys_user u ON c.user_id = u.user_id
+    WHERE c.follow_step7_submitted = 1 
+    AND c.follow_step7_approved = 0 
+    AND c.deleted = 0
+    
+    <if test="step != null">
+        HAVING step = #{step}
+    </if>
+    <if test="customerId != null">
+        HAVING customerId = #{customerId}
+    </if>
+    ORDER BY submittedAt DESC
+</select>
+```
+
+## 🔧 业务逻辑说明
+
+### 1. 步骤解锁机制
+- 第一步始终可用
+- 后续步骤需要前一步审核通过才能进行
+- 前端通过 `canEnterStep` 逻辑控制
+
+### 2. 审核流程
+- 步骤提交后设置 `needApproval = 1`
+- 管理员在后台审核
+- 审核通过后设置 `approved = 1` 并更新时间
+
+### 3. 数据格式
+- 所有复杂数据使用JSON格式存储
+- 文件上传返回URL，存储在JSON数组中
+- 时间统一使用 `YYYY-MM-DD HH:mm:ss` 格式
+
+### 4. 权限控制
+- 销售只能提交和查看自己的客户
+- 管理员可以审核所有步骤
+- 财务人员可以录入第6步回款数据
+
+## 📱 前端集成
+
+前端代码已经完成，包括：
+- 7个步骤的完整页面
+- 步骤状态显示和跳转逻辑
+- 数据提交和验证
+- 客户详情页面的汇总显示
+
+## 🚀 部署步骤
+
+1. 执行数据库迁移脚本
+2. 部署Java后端代码
+3. 更新前端API调用
+4. 测试完整流程
+5. 配置权限和审核流程
+
+## 📝 注意事项
+
+1. **数据备份**：执行数据库变更前请备份
+2. **权限配置**：确保各角色权限正确配置
+3. **文件上传**：确认文件上传服务正常
+4. **审核流程**：测试审核流程的完整性
+5. **性能优化**：大量数据时考虑分页和索引优化
+
+## 🔄 后续扩展
+
+可以考虑的功能：
+- 跟进模板和标准化流程
+- 自动提醒和通知
+- 数据统计和报表
+- 跟进效率分析
+- 客户满意度评估

docs/app_config.sql

@@ -0,0 +1,19 @@
+-- 应用配置表
+CREATE TABLE app_config (
+  config_id INT PRIMARY KEY AUTO_INCREMENT COMMENT '配置ID',
+  website_id INT NOT NULL COMMENT '应用ID',
+  config_key VARCHAR(100) NOT NULL COMMENT '配置键',
+  config_value TEXT NOT NULL COMMENT '配置值（JSON或字符串）',
+  config_type VARCHAR(50) NOT NULL DEFAULT 'general' COMMENT '配置类型：general/api/callback/wechat/payment/git等',
+  is_encrypted TINYINT DEFAULT 0 COMMENT '是否加密 0否 1是',
+  is_secret TINYINT DEFAULT 0 COMMENT '是否敏感信息 0否 1是',
+  description VARCHAR(500) DEFAULT '' COMMENT '配置说明',
+  sort_number INT DEFAULT 0 COMMENT '排序号',
+  tenant_id BIGINT NOT NULL DEFAULT 0 COMMENT '租户id',
+  created_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  updated_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  deleted TINYINT DEFAULT 0 COMMENT '是否删除 0否 1是',
+  UNIQUE KEY uk_website_key (website_id, config_key, deleted),
+  INDEX idx_website_type (website_id, config_type),
+  INDEX idx_tenant (tenant_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='应用配置表';

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/sql/2026-03-18_credit_user_add_indexes.sql

@@ -0,0 +1,34 @@
+-- credit_user 索引优化（MySQL/InnoDB）
+--
+-- 背景：
+-- - credit_user 列表分页默认排序：sort_number asc, create_time desc
+-- - 常见过滤：tenant_id（TenantLine 自动追加）、deleted=0、company_id、user_id、create_time 范围
+-- - 统计/刷新关联数：WHERE deleted=0 AND company_id IN (...) GROUP BY company_id
+--
+-- 使用前建议先查看现有索引，避免重复：
+--   SHOW INDEX FROM credit_user;
+--
+-- 注意：
+-- - 大表加索引会消耗 IO/CPU，建议在低峰执行。
+-- - MySQL 8 可考虑：ALTER TABLE ... ALGORITHM=INPLACE, LOCK=NONE（视版本/引擎而定）。
+
+-- 1) 覆盖默认分页排序 + 逻辑删除 + 租户隔离
+--    典型：WHERE tenant_id=? AND deleted=0 ORDER BY sort_number, create_time DESC LIMIT ...
+CREATE INDEX idx_credit_user_tenant_deleted_sort_create_id
+    ON credit_user (tenant_id, deleted, sort_number, create_time, id);
+
+-- 2) 企业维度查询/统计（也服务于 credit_company 记录数刷新）
+--    典型：WHERE tenant_id=? AND company_id=? AND deleted=0 ...
+--    典型：WHERE tenant_id=? AND deleted=0 AND company_id IN (...) GROUP BY company_id
+CREATE INDEX idx_credit_user_tenant_company_deleted
+    ON credit_user (tenant_id, company_id, deleted);
+
+-- 3) 用户维度查询（后台常按录入人/负责人筛选）
+--    典型：WHERE tenant_id=? AND user_id=? AND deleted=0 ...
+CREATE INDEX idx_credit_user_tenant_user_deleted
+    ON credit_user (tenant_id, user_id, deleted);
+
+-- 可选：如果你们经常按 type 过滤（0/1），再加这个（否则先别加，避免过多索引影响写入）
+-- CREATE INDEX idx_credit_user_tenant_type_deleted
+--     ON credit_user (tenant_id, type, deleted);
+

docs/sql/2026-03-30_app_ticket_tables.sql

@@ -0,0 +1,48 @@
+-- 工单主表
+CREATE TABLE IF NOT EXISTS `app_ticket` (
+  `ticket_id`          BIGINT       NOT NULL AUTO_INCREMENT COMMENT '工单ID',
+  `ticket_no`          VARCHAR(32)  NOT NULL COMMENT '工单编号（TK-yyyyMMddHHmmss+4位随机）',
+  `title`              VARCHAR(200) NOT NULL COMMENT '工单标题',
+  `content`            TEXT         NOT NULL COMMENT '工单内容描述',
+  `website_id`         BIGINT       DEFAULT NULL COMMENT '关联应用ID',
+  `website_name`       VARCHAR(100) DEFAULT NULL COMMENT '应用名称（冗余）',
+  `category`           VARCHAR(30)  NOT NULL DEFAULT 'other' COMMENT '分类: bug/feature/consultation/complaint/other',
+  `priority`           VARCHAR(20)  NOT NULL DEFAULT 'normal' COMMENT '优先级: low/normal/high/urgent',
+  `status`             VARCHAR(20)  NOT NULL DEFAULT 'pending' COMMENT '状态: pending/assigned/processing/resolved/closed/rejected',
+  `attachments`        TEXT         DEFAULT NULL COMMENT '附件JSON数组',
+  `submit_user_id`     INT          NOT NULL COMMENT '提交人用户ID',
+  `submit_user_name`   VARCHAR(50)  DEFAULT NULL COMMENT '提交人昵称（冗余）',
+  `submit_user_avatar` VARCHAR(500) DEFAULT NULL COMMENT '提交人头像（冗余）',
+  `assignee_id`        INT          DEFAULT NULL COMMENT '处理人用户ID',
+  `assignee_name`      VARCHAR(50)  DEFAULT NULL COMMENT '处理人昵称（冗余）',
+  `assignee_avatar`    VARCHAR(500) DEFAULT NULL COMMENT '处理人头像（冗余）',
+  `reply_count`        INT          NOT NULL DEFAULT 0 COMMENT '回复数量',
+  `resolved_time`      DATETIME     DEFAULT NULL COMMENT '解决时间',
+  `closed_time`        DATETIME     DEFAULT NULL COMMENT '关闭时间',
+  `deleted`            TINYINT      NOT NULL DEFAULT 0 COMMENT '是否删除: 0否 1是',
+  `create_time`        DATETIME     NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `update_time`        DATETIME     NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`ticket_id`),
+  UNIQUE KEY `uk_ticket_no` (`ticket_no`),
+  KEY `idx_submit_user` (`submit_user_id`),
+  KEY `idx_assignee` (`assignee_id`),
+  KEY `idx_website_status` (`website_id`, `status`),
+  KEY `idx_status_create` (`status`, `create_time`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='应用工单';
+
+-- 工单回复表
+CREATE TABLE IF NOT EXISTS `app_ticket_reply` (
+  `reply_id`    BIGINT       NOT NULL AUTO_INCREMENT COMMENT '回复ID',
+  `ticket_id`   BIGINT       NOT NULL COMMENT '关联工单ID',
+  `content`     TEXT         NOT NULL COMMENT '回复内容',
+  `attachments` TEXT         DEFAULT NULL COMMENT '附件JSON数组',
+  `user_id`     INT          NOT NULL COMMENT '回复人用户ID',
+  `user_name`   VARCHAR(50)  DEFAULT NULL COMMENT '回复人昵称（冗余）',
+  `user_avatar` VARCHAR(500) DEFAULT NULL COMMENT '回复人头像（冗余）',
+  `is_staff`    TINYINT      NOT NULL DEFAULT 0 COMMENT '是否技术人员/客服: 0否 1是',
+  `deleted`     TINYINT      NOT NULL DEFAULT 0 COMMENT '是否删除: 0否 1是',
+  `create_time` DATETIME     NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  PRIMARY KEY (`reply_id`),
+  KEY `idx_ticket_id` (`ticket_id`),
+  KEY `idx_user_id` (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='工单回复';

docs/sql/credit_mp_customer_step1_4_approval_columns.sql

@@ -0,0 +1,24 @@
+-- 修复：审核接口(updateStepApproval)会写入 follow_step{1..4}_approved_at / follow_step{1..4}_approved_by
+-- 若数据库缺少这些列，会触发：Unknown column 'follow_step1_approved_at' in 'field list'
+--
+-- 建议先检查：
+--   SHOW COLUMNS FROM credit_mp_customer LIKE 'follow_step%_approved%';
+--
+-- 然后按需执行下面的 ALTER TABLE（如果你的 MySQL 版本支持，也可以改为 ADD COLUMN IF NOT EXISTS）。
+
+-- 第1步：案件受理
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step1_approved_at VARCHAR(255) NULL COMMENT '第1步审核时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step1_approved_by BIGINT NULL COMMENT '第1步审核人ID';
+
+-- 第2步：材料准备
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step2_approved_at VARCHAR(255) NULL COMMENT '第2步审核时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step2_approved_by BIGINT NULL COMMENT '第2步审核人ID';
+
+-- 第3步：案件办理
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step3_approved_at VARCHAR(255) NULL COMMENT '第3步审核时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step3_approved_by BIGINT NULL COMMENT '第3步审核人ID';
+
+-- 第4步：送达签收
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step4_approved_at VARCHAR(255) NULL COMMENT '第4步审核时间';
+ALTER TABLE credit_mp_customer ADD COLUMN follow_step4_approved_by BIGINT NULL COMMENT '第4步审核人ID';
+

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>

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 ""

src/main/java/com/gxwebsoft/app/controller/AppConfigController.java

@@ -0,0 +1,129 @@
+package com.gxwebsoft.app.controller;
+
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.app.entity.AppConfig;
+import com.gxwebsoft.app.param.AppConfigParam;
+import com.gxwebsoft.app.service.AppConfigService;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.PageResult;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 应用配置表 Controller
+ */
+@Slf4j
+@Tag(name = "应用配置管理")
+@RestController
+@RequestMapping("/api/app/app-config")
+public class AppConfigController extends BaseController {
+
+    @Resource
+    private AppConfigService appConfigService;
+
+    /**
+     * 分页查询应用配置
+     */
+    @Operation(summary = "分页查询应用配置")
+    @GetMapping("/page")
+    public ApiResult<PageResult<AppConfig>> page(AppConfigParam param) {
+        return success(new PageResult<>(appConfigService.page(param)));
+    }
+
+    /**
+     * 获取应用配置列表
+     */
+    @Operation(summary = "获取应用配置列表")
+    @GetMapping()
+    public ApiResult<List<AppConfig>> list(AppConfigParam param) {
+        return success(appConfigService.list(param));
+    }
+
+    /**
+     * 根据应用ID获取配置映射
+     */
+    @Operation(summary = "根据应用ID获取配置映射")
+    @GetMapping("/map/{websiteId}")
+    public ApiResult<Map<String, Object>> getConfigsByWebsiteId(@PathVariable Integer websiteId) {
+        return success(appConfigService.getConfigsByWebsiteId(websiteId));
+    }
+
+    /**
+     * 获取单个配置值
+     */
+    @Operation(summary = "获取单个配置值")
+    @GetMapping("/value")
+    public ApiResult<String> getConfigValue(@RequestParam Integer websiteId, @RequestParam String configKey) {
+        return success(appConfigService.getConfigValue(websiteId, configKey),null);
+    }
+
+    /**
+     * 保存配置
+     */
+    @Operation(summary = "保存配置")
+    @PostMapping()
+    public ApiResult<?> save(@RequestBody AppConfig config) {
+        appConfigService.saveConfig(config);
+        return success("保存成功");
+    }
+
+    /**
+     * 批量保存配置
+     */
+    @Operation(summary = "批量保存配置")
+    @PostMapping("/batch")
+    public ApiResult<?> batchSave(@RequestBody BatchSaveRequest request) {
+        appConfigService.batchSaveConfig(request.getWebsiteId(), request.getConfigs());
+        return success("保存成功");
+    }
+
+    /**
+     * 更新配置
+     */
+    @Operation(summary = "更新配置")
+    @PutMapping()
+    public ApiResult<?> update(@RequestBody AppConfig config) {
+        appConfigService.updateConfig(config);
+        return success("更新成功");
+    }
+
+    /**
+     * 删除配置
+     */
+    @Operation(summary = "删除配置")
+    @DeleteMapping("/{configId}")
+    public ApiResult<?> delete(@PathVariable Integer configId) {
+        appConfigService.deleteConfig(configId);
+        return success("删除成功");
+    }
+
+    /**
+     * 批量保存请求对象
+     */
+    public static class BatchSaveRequest {
+        private Integer websiteId;
+        private List<AppConfig> configs;
+
+        public Integer getWebsiteId() {
+            return websiteId;
+        }
+
+        public void setWebsiteId(Integer websiteId) {
+            this.websiteId = websiteId;
+        }
+
+        public List<AppConfig> getConfigs() {
+            return configs;
+        }
+
+        public void setConfigs(List<AppConfig> configs) {
+            this.configs = configs;
+        }
+    }
+}

src/main/java/com/gxwebsoft/app/controller/AppCredentialController.java

@@ -0,0 +1,151 @@
+package com.gxwebsoft.app.controller;
+
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.app.service.AppCredentialService;
+import com.gxwebsoft.app.entity.AppCredential;
+import com.gxwebsoft.app.param.AppCredentialParam;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.core.web.BatchParam;
+import com.gxwebsoft.common.core.annotation.OperationLog;
+import com.gxwebsoft.common.system.entity.User;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 应用密钥凭证控制器
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Slf4j
+@Tag(name = "应用密钥凭证管理")
+@RestController
+@RequestMapping("/api/app/app-credential")
+public class AppCredentialController extends BaseController {
+
+    @Resource
+    private AppCredentialService appCredentialService;
+
+    @Operation(summary = "分页查询应用密钥凭证")
+    @GetMapping("/page")
+    public ApiResult<PageResult<AppCredential>> page(AppCredentialParam param) {
+        return success(appCredentialService.pageRel(param));
+    }
+
+    @Operation(summary = "查询全部应用密钥凭证")
+    @GetMapping()
+    public ApiResult<List<AppCredential>> list(AppCredentialParam param) {
+        return success(appCredentialService.listRel(param));
+    }
+
+    @Operation(summary = "根据id查询应用密钥凭证")
+    @GetMapping("/{id}")
+    public ApiResult<AppCredential> get(@PathVariable("id") Integer id) {
+        return success(appCredentialService.getByIdRel(id));
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:save')")
+    @OperationLog
+    @Operation(summary = "创建应用密钥凭证（自动生成 AppID 和 AppSecret）")
+    @PostMapping()
+    public ApiResult<?> save(@RequestBody AppCredential appCredential) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) {
+            return fail("请先登录");
+        }
+        appCredential.setUserId(loginUser.getUserId());
+        // 创建并生成密钥
+        AppCredential result = appCredentialService.createCredential(appCredential);
+        return success("创建成功，请保存 AppSecret，该信息仅展示一次", result);
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:update')")
+    @OperationLog
+    @Operation(summary = "修改应用密钥凭证（名称/类型/备注等，不含密钥）")
+    @PutMapping()
+    public ApiResult<?> update(@RequestBody AppCredential appCredential) {
+        // 防止通过此接口直接修改 appId/appSecret
+        appCredential.setAppId(null);
+        appCredential.setAppSecret(null);
+        if (appCredentialService.updateById(appCredential)) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:update')")
+    @OperationLog
+    @Operation(summary = "重置 AppSecret（重新生成密钥）")
+    @PostMapping("/resetSecret/{id}")
+    public ApiResult<?> resetSecret(@PathVariable("id") Long id) {
+        try {
+            AppCredential result = appCredentialService.resetSecret(id);
+            return success("重置成功，请保存新 AppSecret，该信息仅展示一次", result);
+        } catch (RuntimeException e) {
+            return fail(e.getMessage());
+        }
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:update')")
+    @OperationLog
+    @Operation(summary = "禁用/启用凭证")
+    @PutMapping("/status/{id}/{status}")
+    public ApiResult<?> updateStatus(@PathVariable("id") Long id, @PathVariable("status") Integer status) {
+        if (appCredentialService.updateStatus(id, status)) {
+            return success(status == 0 ? "已启用" : "已禁用");
+        }
+        return fail("操作失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:remove')")
+    @OperationLog
+    @Operation(summary = "删除应用密钥凭证")
+    @DeleteMapping("/{id}")
+    public ApiResult<?> remove(@PathVariable("id") Integer id) {
+        if (appCredentialService.removeById(id)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:save')")
+    @OperationLog
+    @Operation(summary = "批量添加应用密钥凭证")
+    @PostMapping("/batch")
+    public ApiResult<?> saveBatch(@RequestBody List<AppCredential> list) {
+        if (appCredentialService.saveBatch(list)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:update')")
+    @OperationLog
+    @Operation(summary = "批量修改应用密钥凭证")
+    @PutMapping("/batch")
+    public ApiResult<?> updateBatch(@RequestBody BatchParam<AppCredential> batchParam) {
+        if (batchParam.update(appCredentialService, "id")) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appCredential:remove')")
+    @OperationLog
+    @Operation(summary = "批量删除应用密钥凭证")
+    @DeleteMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
+        if (appCredentialService.removeByIds(ids)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+}

src/main/java/com/gxwebsoft/app/controller/AppEventController.java

@@ -0,0 +1,133 @@
+package com.gxwebsoft.app.controller;
+
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.app.service.AppEventService;
+import com.gxwebsoft.app.entity.AppEvent;
+import com.gxwebsoft.app.param.AppEventParam;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.core.annotation.OperationLog;
+import com.gxwebsoft.common.system.entity.User;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 应用操作动态控制器
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Slf4j
+@Tag(name = "应用操作动态管理")
+@RestController
+@RequestMapping("/api/app/app-event")
+public class AppEventController extends BaseController {
+
+    @Resource
+    private AppEventService appEventService;
+
+    @Operation(summary = "分页查询操作动态")
+    @GetMapping("/page")
+    public ApiResult<PageResult<AppEvent>> page(AppEventParam param) {
+        return success(appEventService.pageRel(param));
+    }
+
+    @Operation(summary = "查询全部操作动态")
+    @GetMapping()
+    public ApiResult<List<AppEvent>> list(AppEventParam param) {
+        return success(appEventService.listRel(param));
+    }
+
+    @Operation(summary = "根据id查询操作动态")
+    @GetMapping("/{id}")
+    public ApiResult<AppEvent> get(@PathVariable("id") Integer id) {
+        return success(appEventService.getByIdRel(id));
+    }
+
+    @Operation(summary = "获取应用最新一条动态（用于卡片展示）")
+    @GetMapping("/latest/{websiteId}")
+    public ApiResult<AppEvent> getLatest(@PathVariable("websiteId") Long websiteId) {
+        return success(appEventService.getLatestEvent(websiteId));
+    }
+
+    @PreAuthorize("hasAuthority('app:appEvent:save')")
+    @OperationLog
+    @Operation(summary = "手动记录操作动态")
+    @PostMapping()
+    public ApiResult<?> save(@RequestBody AppEvent appEvent) {
+        User loginUser = getLoginUser();
+        if (loginUser != null) {
+            appEvent.setUserId(loginUser.getUserId());
+            appEvent.setTenantId(loginUser.getTenantId());
+            if (appEvent.getOperatorId() == null) {
+                appEvent.setOperatorId(loginUser.getUserId().longValue());
+            }
+            if (appEvent.getOperator() == null) {
+                appEvent.setOperator(loginUser.getNickname());
+            }
+        }
+        if (appEventService.save(appEvent)) {
+            return success("记录成功");
+        }
+        return fail("记录失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appEvent:update')")
+    @OperationLog
+    @Operation(summary = "修改操作动态")
+    @PutMapping()
+    public ApiResult<?> update(@RequestBody AppEvent appEvent) {
+        if (appEventService.updateById(appEvent)) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appEvent:remove')")
+    @OperationLog
+    @Operation(summary = "删除操作动态")
+    @DeleteMapping("/{id}")
+    public ApiResult<?> remove(@PathVariable("id") Integer id) {
+        if (appEventService.removeById(id)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appEvent:remove')")
+    @OperationLog
+    @Operation(summary = "清空应用所有动态记录")
+    @DeleteMapping("/clear/{websiteId}")
+    public ApiResult<?> clearByWebsiteId(@PathVariable("websiteId") Long websiteId) {
+        // 只清空当前租户下的数据
+        AppEventParam param = new AppEventParam();
+        param.setWebsiteId(websiteId);
+        List<AppEvent> list = appEventService.listRel(param);
+        if (list.isEmpty()) {
+            return success("暂无动态记录");
+        }
+        List<Long> ids = list.stream().map(AppEvent::getId).collect(java.util.stream.Collectors.toList());
+        if (appEventService.removeByIds(ids)) {
+            return success("已清空 " + ids.size() + " 条动态记录");
+        }
+        return fail("清空失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appEvent:remove')")
+    @OperationLog
+    @Operation(summary = "批量删除操作动态")
+    @DeleteMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
+        if (appEventService.removeByIds(ids)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+}

src/main/java/com/gxwebsoft/app/controller/AppResourceController.java

@@ -0,0 +1,145 @@
+package com.gxwebsoft.app.controller;
+
+import com.gxwebsoft.app.entity.AppResource;
+import com.gxwebsoft.app.param.AppResourceParam;
+import com.gxwebsoft.app.service.AppResourceService;
+import com.gxwebsoft.common.core.annotation.OperationLog;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.system.entity.User;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 开发者资源管理控制器（服务器/数据库/云存储/域名/SSL）
+ *
+ * @author 科技小王子
+ * @since 2026-03-31
+ */
+@Slf4j
+@Tag(name = "开发者资源管理")
+@RestController
+@RequestMapping("/api/app/developer-resource")
+public class AppResourceController extends BaseController {
+
+    @Resource
+    private AppResourceService appResourceService;
+
+    // ─── 查询接口 ─────────────────────────────────────────────────
+
+    @Operation(summary = "分页查询资源列表")
+    @GetMapping("/page")
+    public ApiResult<PageResult<AppResource>> page(AppResourceParam param) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录", null);
+        // 普通开发者只能查自己的资源
+        param.setUserId(loginUser.getUserId());
+        param.setTenantId(loginUser.getTenantId());
+        return success(appResourceService.pageRel(param));
+    }
+
+    @Operation(summary = "查询资源列表（不分页）")
+    @GetMapping
+    public ApiResult<List<AppResource>> list(AppResourceParam param) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录", null);
+        param.setUserId(loginUser.getUserId());
+        param.setTenantId(loginUser.getTenantId());
+        return success(appResourceService.listRel(param));
+    }
+
+    @Operation(summary = "获取资源详情")
+    @GetMapping("/{resourceId}")
+    public ApiResult<AppResource> get(@PathVariable Long resourceId) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录", null);
+        AppResource resource = appResourceService.getByIdRel(resourceId);
+        if (resource == null) return fail("资源不存在", null);
+        if (!resource.getUserId().equals(loginUser.getUserId())) return fail("无权访问此资源", null);
+        return success(resource);
+    }
+
+    @Operation(summary = "统计各类型资源数量")
+    @GetMapping("/stats")
+    public ApiResult<Map<String, Long>> stats() {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录", null);
+        return success(appResourceService.countByType(loginUser.getUserId(), loginUser.getTenantId()));
+    }
+
+    // ─── 新增/修改接口 ────────────────────────────────────────────
+
+    @OperationLog
+    @Operation(summary = "新增资源")
+    @PostMapping
+    public ApiResult<AppResource> save(@RequestBody AppResource resource) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录", null);
+        if (resource.getResourceType() == null || resource.getResourceType().isEmpty()) {
+            return fail("资源类型不能为空", null);
+        }
+        if (resource.getName() == null || resource.getName().isEmpty()) {
+            return fail("资源名称不能为空", null);
+        }
+        resource.setTenantId(loginUser.getTenantId());
+        try {
+            AppResource result = appResourceService.addResource(resource, loginUser.getUserId());
+            return success("添加成功", result);
+        } catch (Exception e) {
+            return fail(e.getMessage(), null);
+        }
+    }
+
+    @OperationLog
+    @Operation(summary = "修改资源")
+    @PutMapping
+    public ApiResult<AppResource> update(@RequestBody AppResource resource) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录", null);
+        try {
+            AppResource result = appResourceService.updateResource(resource);
+            return success("修改成功", result);
+        } catch (Exception e) {
+            return fail(e.getMessage(), null);
+        }
+    }
+
+    // ─── 删除接口 ─────────────────────────────────────────────────
+
+    @OperationLog
+    @Operation(summary = "删除资源（逻辑删除）")
+    @DeleteMapping("/{resourceId}")
+    public ApiResult<?> remove(@PathVariable Long resourceId) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录");
+        try {
+            appResourceService.removeResource(resourceId, loginUser.getUserId());
+            return success("删除成功");
+        } catch (Exception e) {
+            return fail(e.getMessage());
+        }
+    }
+
+    @OperationLog
+    @Operation(summary = "批量删除资源")
+    @DeleteMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody List<Long> ids) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录");
+        try {
+            for (Long id : ids) {
+                appResourceService.removeResource(id, loginUser.getUserId());
+            }
+            return success("批量删除成功");
+        } catch (Exception e) {
+            return fail(e.getMessage());
+        }
+    }
+}

src/main/java/com/gxwebsoft/app/controller/AppTicketController.java

@@ -0,0 +1,150 @@
+package com.gxwebsoft.app.controller;
+
+import com.gxwebsoft.app.entity.AppTicket;
+import com.gxwebsoft.app.entity.AppTicketReply;
+import com.gxwebsoft.app.param.AppTicketParam;
+import com.gxwebsoft.app.service.AppTicketService;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.system.entity.User;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 应用工单控制器
+ *
+ * @author 科技小王子
+ * @since 2026-03-30
+ */
+@Slf4j
+@Tag(name = "应用工单管理")
+@RestController
+@RequestMapping("/api/app/ticket")
+public class AppTicketController extends BaseController {
+
+    @Resource
+    private AppTicketService appTicketService;
+
+    // ─── 客户端接口 ────────────────────────────────────────────────
+
+    @Operation(summary = "查询我的工单（分页）")
+    @GetMapping("/my")
+    public ApiResult<PageResult<AppTicket>> myTickets(AppTicketParam param) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录",null);
+        return success(appTicketService.myPage(param, loginUser.getUserId()));
+    }
+
+    @Operation(summary = "提交工单")
+    @PostMapping("/submit")
+    public ApiResult<AppTicket> submit(@RequestBody AppTicket ticket) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录",null);
+        try {
+            AppTicket result = appTicketService.submit(ticket, loginUser.getUserId());
+            return success("工单提交成功", result);
+        } catch (Exception e) {
+            return fail(e.getMessage(),null);
+        }
+    }
+
+    @Operation(summary = "关闭工单（提交人）")
+    @PutMapping("/{ticketId}/close")
+    public ApiResult<?> close(@PathVariable Long ticketId) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录");
+        try {
+            appTicketService.closeByUser(ticketId, loginUser.getUserId());
+            return success("工单已关闭");
+        } catch (Exception e) {
+            return fail(e.getMessage());
+        }
+    }
+
+    // ─── 技术端接口 ────────────────────────────────────────────────
+
+    @Operation(summary = "查询所有工单（技术人员）")
+    @GetMapping("/list")
+    public ApiResult<PageResult<AppTicket>> allTickets(AppTicketParam param) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录",null);
+        return success(appTicketService.allPage(param));
+    }
+
+    @Operation(summary = "获取工单详情")
+    @GetMapping("/{ticketId}")
+    public ApiResult<AppTicket> detail(@PathVariable Long ticketId) {
+        return success(appTicketService.getById(ticketId));
+    }
+
+    @Operation(summary = "更新工单状态（技术人员）")
+    @PutMapping("/status")
+    public ApiResult<?> updateStatus(@RequestBody Map<String, Object> body) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录");
+        Long ticketId = Long.valueOf(body.get("ticketId").toString());
+        String status = body.get("status").toString();
+        appTicketService.updateStatus(ticketId, status, loginUser.getUserId());
+        return success("状态已更新");
+    }
+
+    @Operation(summary = "分配处理人（管理员）")
+    @PutMapping("/assign")
+    public ApiResult<?> assign(@RequestBody Map<String, Object> body) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录");
+        Long ticketId = Long.valueOf(body.get("ticketId").toString());
+        Integer assigneeId = Integer.valueOf(body.get("assigneeId").toString());
+        appTicketService.assign(ticketId, assigneeId);
+        return success("分配成功");
+    }
+
+    // ─── 回复接口 ─────────────────────────────────────────────────
+
+    @Operation(summary = "获取工单回复列表")
+    @GetMapping("/{ticketId}/replies")
+    public ApiResult<List<AppTicketReply>> replies(@PathVariable Long ticketId) {
+        return success(appTicketService.getReplies(ticketId));
+    }
+
+    @Operation(summary = "提交工单回复")
+    @PostMapping("/reply")
+    public ApiResult<AppTicketReply> reply(@RequestBody AppTicketReply reply) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录",null);
+        if (reply.getContent() == null || reply.getContent().trim().isEmpty()) {
+            return fail("回复内容不能为空",null);
+        }
+        try {
+            AppTicketReply result = appTicketService.addReply(reply, loginUser.getUserId());
+            return success("回复成功", result);
+        } catch (Exception e) {
+            return fail(e.getMessage(),null);
+        }
+    }
+
+    // ─── 统计 & 辅助 ─────────────────────────────────────────────
+
+    @Operation(summary = "工单统计数据")
+    @GetMapping("/stats")
+    public ApiResult<Map<String, Long>> stats(
+            @RequestParam(required = false) Long websiteId) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) return fail("请先登录",null);
+        // 技术端不限制用户维度；客户端通过路由区分
+        return success(appTicketService.stats(websiteId, null));
+    }
+
+    @Operation(summary = "获取技术人员列表（用于分配）")
+    @GetMapping("/staff-list")
+    public ApiResult<List<Map<String, Object>>> staffList() {
+        return success(appTicketService.getTechStaffList());
+    }
+}

src/main/java/com/gxwebsoft/app/controller/AppUserController.java

@@ -0,0 +1,167 @@
+package com.gxwebsoft.app.controller;
+
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.app.service.AppUserService;
+import com.gxwebsoft.app.entity.AppUser;
+import com.gxwebsoft.app.param.AppUserParam;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.core.web.BatchParam;
+import com.gxwebsoft.common.core.annotation.OperationLog;
+import com.gxwebsoft.common.system.entity.User;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 应用成员控制器
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Slf4j
+@Tag(name = "应用成员管理")
+@RestController
+@RequestMapping("/api/app/app-user")
+public class AppUserController extends BaseController {
+
+    @Resource
+    private AppUserService appUserService;
+
+    @Operation(summary = "分页查询应用成员")
+    @GetMapping("/page")
+    public ApiResult<PageResult<AppUser>> page(AppUserParam param) {
+        return success(appUserService.pageRel(param));
+    }
+
+    @Operation(summary = "查询全部应用成员")
+    @GetMapping()
+    public ApiResult<List<AppUser>> list(AppUserParam param) {
+        return success(appUserService.listRel(param));
+    }
+
+    @Operation(summary = "根据id查询应用成员")
+    @GetMapping("/{id}")
+    public ApiResult<AppUser> get(@PathVariable("id") Integer id) {
+        return success(appUserService.getByIdRel(id));
+    }
+
+    @PreAuthorize("hasAuthority('app:appUser:save')")
+    @OperationLog
+    @Operation(summary = "添加应用成员（手动添加）")
+    @PostMapping()
+    public ApiResult<?> save(@RequestBody AppUser appUser) {
+        User loginUser = getLoginUser();
+        if (loginUser != null) {
+            appUser.setUserId(loginUser.getUserId());
+            appUser.setTenantId(loginUser.getTenantId());
+        }
+        if (appUserService.save(appUser)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @Operation(summary = "邀请用户成为应用成员（支持用户ID或手机号）")
+    @PostMapping("/invite")
+    public ApiResult<?> invite(@RequestBody AppUser appUser) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) {
+            return fail("请先登录");
+        }
+        // 支持手机号邀请：若 userId 为空但传了 phone，则先按手机号查出用户
+        if (appUser.getUserId() == null && appUser.getPhone() != null && !appUser.getPhone().isEmpty()) {
+            User targetUser = appUserService.findUserByPhone(appUser.getPhone());
+            if (targetUser == null) {
+                return fail("手机号未注册，请确认后再试");
+            }
+            appUser.setUserId(targetUser.getUserId());
+        }
+        if (appUser.getUserId() == null) {
+            return fail("请输入用户ID或手机号");
+        }
+        try {
+            AppUser result = appUserService.inviteUser(
+                    appUser.getWebsiteId(),
+                    appUser.getUserId(),
+                    appUser.getRole(),
+                    loginUser.getUserId()
+            );
+            return success("邀请成功", result);
+        } catch (RuntimeException e) {
+            return fail(e.getMessage());
+        }
+    }
+
+    @PreAuthorize("hasAuthority('app:appUser:update')")
+    @OperationLog
+    @Operation(summary = "修改应用成员信息")
+    @PutMapping()
+    public ApiResult<?> update(@RequestBody AppUser appUser) {
+        if (appUserService.updateById(appUser)) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appUser:update')")
+    @OperationLog
+    @Operation(summary = "修改成员角色")
+    @PutMapping("/role/{id}/{role}")
+    public ApiResult<?> updateRole(@PathVariable("id") Long id, @PathVariable("role") String role) {
+        if (appUserService.updateRole(id, role)) {
+            return success("角色修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appUser:remove')")
+    @OperationLog
+    @Operation(summary = "移除应用成员")
+    @DeleteMapping("/{id}")
+    public ApiResult<?> remove(@PathVariable("id") Integer id) {
+        if (appUserService.removeById(id)) {
+            return success("已移除");
+        }
+        return fail("移除失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appUser:save')")
+    @OperationLog
+    @Operation(summary = "批量添加应用成员")
+    @PostMapping("/batch")
+    public ApiResult<?> saveBatch(@RequestBody List<AppUser> list) {
+        if (appUserService.saveBatch(list)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appUser:update')")
+    @OperationLog
+    @Operation(summary = "批量修改应用成员")
+    @PutMapping("/batch")
+    public ApiResult<?> updateBatch(@RequestBody BatchParam<AppUser> batchParam) {
+        if (batchParam.update(appUserService, "id")) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appUser:remove')")
+    @OperationLog
+    @Operation(summary = "批量移除应用成员")
+    @DeleteMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
+        if (appUserService.removeByIds(ids)) {
+            return success("移除成功");
+        }
+        return fail("移除失败");
+    }
+
+}

src/main/java/com/gxwebsoft/app/controller/AppVersionController.java

@@ -0,0 +1,173 @@
+package com.gxwebsoft.app.controller;
+
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.app.service.AppVersionService;
+import com.gxwebsoft.app.entity.AppVersion;
+import com.gxwebsoft.app.param.AppVersionParam;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.core.web.BatchParam;
+import com.gxwebsoft.common.core.annotation.OperationLog;
+import com.gxwebsoft.common.system.entity.User;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 应用版本发布记录控制器
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Slf4j
+@Tag(name = "应用版本发布管理")
+@RestController
+@RequestMapping("/api/app/app-version")
+public class AppVersionController extends BaseController {
+
+    @Resource
+    private AppVersionService appVersionService;
+
+    @Operation(summary = "分页查询版本记录")
+    @GetMapping("/page")
+    public ApiResult<PageResult<AppVersion>> page(AppVersionParam param) {
+        return success(appVersionService.pageRel(param));
+    }
+
+    @Operation(summary = "查询全部版本记录")
+    @GetMapping()
+    public ApiResult<List<AppVersion>> list(AppVersionParam param) {
+        return success(appVersionService.listRel(param));
+    }
+
+    @Operation(summary = "根据id查询版本")
+    @GetMapping("/{id}")
+    public ApiResult<AppVersion> get(@PathVariable("id") Integer id) {
+        return success(appVersionService.getByIdRel(id));
+    }
+
+    @Operation(summary = "获取应用当前版本")
+    @GetMapping("/current/{websiteId}")
+    public ApiResult<AppVersion> getCurrentVersion(@PathVariable("websiteId") Long websiteId) {
+        return success(appVersionService.getCurrentVersion(websiteId));
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:save')")
+    @OperationLog
+    @Operation(summary = "新增版本（构建中状态）")
+    @PostMapping()
+    public ApiResult<?> save(@RequestBody AppVersion appVersion) {
+        User loginUser = getLoginUser();
+        if (loginUser != null) {
+            appVersion.setUserId(loginUser.getUserId());
+            appVersion.setTenantId(loginUser.getTenantId());
+        }
+        // 默认为构建中状态
+        if (appVersion.getStatus() == null) {
+            appVersion.setStatus(0);
+        }
+        if (appVersion.getEnv() == null) {
+            appVersion.setEnv("production");
+        }
+        appVersion.setIsCurrent(false);
+        if (appVersionService.save(appVersion)) {
+            return success("创建成功");
+        }
+        return fail("创建失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:update')")
+    @OperationLog
+    @Operation(summary = "修改版本信息")
+    @PutMapping()
+    public ApiResult<?> update(@RequestBody AppVersion appVersion) {
+        if (appVersionService.updateById(appVersion)) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:update')")
+    @OperationLog
+    @Operation(summary = "发布版本（将此版本设为当前运行版本）")
+    @PostMapping("/publish/{id}")
+    public ApiResult<?> publish(@PathVariable("id") Long id) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) {
+            return fail("请先登录");
+        }
+        try {
+            appVersionService.publish(id, loginUser.getUserId());
+            return success("发布成功");
+        } catch (RuntimeException e) {
+            return fail(e.getMessage());
+        }
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:update')")
+    @OperationLog
+    @Operation(summary = "回滚到指定版本")
+    @PostMapping("/rollback/{id}")
+    public ApiResult<?> rollback(@PathVariable("id") Long id) {
+        User loginUser = getLoginUser();
+        if (loginUser == null) {
+            return fail("请先登录");
+        }
+        try {
+            appVersionService.rollback(id, loginUser.getUserId());
+            return success("回滚成功");
+        } catch (RuntimeException e) {
+            return fail(e.getMessage());
+        }
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:remove')")
+    @OperationLog
+    @Operation(summary = "删除版本记录")
+    @DeleteMapping("/{id}")
+    public ApiResult<?> remove(@PathVariable("id") Integer id) {
+        if (appVersionService.removeById(id)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:save')")
+    @OperationLog
+    @Operation(summary = "批量添加版本")
+    @PostMapping("/batch")
+    public ApiResult<?> saveBatch(@RequestBody List<AppVersion> list) {
+        if (appVersionService.saveBatch(list)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:update')")
+    @OperationLog
+    @Operation(summary = "批量修改版本")
+    @PutMapping("/batch")
+    public ApiResult<?> updateBatch(@RequestBody BatchParam<AppVersion> batchParam) {
+        if (batchParam.update(appVersionService, "id")) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('app:appVersion:remove')")
+    @OperationLog
+    @Operation(summary = "批量删除版本记录")
+    @DeleteMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
+        if (appVersionService.removeByIds(ids)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+}

src/main/java/com/gxwebsoft/app/entity/AppConfig.java

@@ -0,0 +1,87 @@
+package com.gxwebsoft.app.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+
+/**
+ * 应用配置表
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("app_config")
+public class AppConfig implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 配置ID
+     */
+    @TableId(value = "config_id", type = IdType.AUTO)
+    private Integer configId;
+
+    /**
+     * 应用ID
+     */
+    private Integer websiteId;
+
+    /**
+     * 配置键
+     */
+    private String configKey;
+
+    /**
+     * 配置值（JSON或字符串）
+     */
+    private String configValue;
+
+    /**
+     * 配置类型：general/api/callback/wechat/payment/git等
+     */
+    private String configType;
+
+    /**
+     * 是否加密 0否 1是
+     */
+    private Integer isEncrypted;
+
+    /**
+     * 是否敏感信息 0否 1是
+     */
+    private Integer isSecret;
+
+    /**
+     * 配置说明
+     */
+    private String description;
+
+    /**
+     * 排序号
+     */
+    private Integer sortNumber;
+
+    /**
+     * 租户id
+     */
+    private Long tenantId;
+
+    /**
+     * 创建时间
+     */
+    @TableField(fill = FieldFill.INSERT)
+    private Long createdTime;
+
+    /**
+     * 更新时间
+     */
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private Long updatedTime;
+
+    /**
+     * 是否删除 0否 1是
+     */
+    @TableLogic
+    private Integer deleted;
+}

src/main/java/com/gxwebsoft/app/entity/AppCredential.java

@@ -1,70 +1,57 @@
-package com.gxwebsoft.credit.entity;
+package com.gxwebsoft.app.entity;
 
 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 com.fasterxml.jackson.annotation.JsonFormat;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
-import java.io.Serializable;
-import java.time.LocalDateTime;
-
 /**
- * 被执行人
+ * 应用密钥凭证
  *
  * @author 科技小王子
- * @since 2026-01-12 08:10:43
+ * @since 2026-03-28 21:29:43
  */
 @Data
 @EqualsAndHashCode(callSuper = false)
-@Schema(name = "CreditJudgmentDebtorHistory对象", description = "被执行人")
-public class CreditJudgmentDebtorHistory implements Serializable {
+@Schema(name = "AppCredential对象", description = "应用密钥凭证")
+public class AppCredential implements Serializable {
     private static final long serialVersionUID = 1L;
 
-    @Schema(description = "ID")
+    @Schema(description = "自增ID")
     @TableId(value = "id", type = IdType.AUTO)
-    private Integer id;
+    private Long id;
 
-    @Schema(description = "案号")
-    private String caseNumber;
+    @Schema(description = "关联应用ID")
+    private Long websiteId;
 
-    @Schema(description = "被执行人名称")
+    @Schema(description = "凭证名称，如生产环境密钥")
     private String name;
 
-    @Schema(description = "被执行人")
-    private String name1;
+    @Schema(description = "App ID（公开）")
+    private String appId;
 
-    @Schema(description = "证件号/组织机构代码")
-    private String code;
+    @Schema(description = "App Secret（加密存储）")
+    private String appSecret;
 
-    @Schema(description = "链接")
-    private String url;
+    @Schema(description = "凭证类型: server/client/webhook")
+    private String type;
 
-    @Schema(description = "是否多企业")
-    private Integer type;
+    @Schema(description = "权限范围，空格分隔")
+    private String scopes;
 
-    @Schema(description = "立案日期")
-    private String occurrenceTime;
+    @Schema(description = "到期时间，NULL=永不过期")
+    private LocalDateTime expireTime;
 
-    @Schema(description = "执行标的(元)")
-    private String amount;
+    @Schema(description = "最后使用时间")
+    private LocalDateTime lastUsedAt;
 
-    @Schema(description = "法院")
-    private String courtName;
-
-    @Schema(description = "数据状态")
-    private String dataStatus;
-
-    @Schema(description = "企业ID")
-    private Integer companyId;
-
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "是否推荐")
-    private Integer recommend;
+    private String remark;
 
     @Schema(description = "排序(数字越小越靠前)")
     private Integer sortNumber;

src/main/java/com/gxwebsoft/app/entity/AppEvent.java

@@ -0,0 +1,76 @@
+package com.gxwebsoft.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import java.io.Serializable;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 应用操作动态
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Schema(name = "AppEvent对象", description = "应用操作动态")
+public class AppEvent implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "自增ID")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    @Schema(description = "关联应用ID")
+    private Long websiteId;
+
+    @Schema(description = "事件类型: created/published/updated/domain_bound/member_added/status_changed")
+    private String eventType;
+
+    @Schema(description = "事件标题，如已发布")
+    private String title;
+
+    @Schema(description = "详细描述")
+    private String content;
+
+    @Schema(description = "操作人用户ID")
+    private Long operatorId;
+
+    @Schema(description = "操作人名称（冗余）")
+    private String operator;
+
+    @Schema(description = "关联ID，如版本ID")
+    private Long refId;
+
+    @Schema(description = "关联类型")
+    private String refType;
+
+    @Schema(description = "扩展数据")
+    private String extra;
+
+    @Schema(description = "排序(数字越小越靠前)")
+    private Integer sortNumber;
+
+    @Schema(description = "状态, 0正常, 1冻结")
+    private Integer status;
+
+    @Schema(description = "用户ID")
+    private Integer userId;
+
+    @Schema(description = "租户id")
+    private Integer tenantId;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+    @Schema(description = "修改时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+
+}

src/main/java/com/gxwebsoft/app/entity/AppResource.java

@@ -0,0 +1,121 @@
+package com.gxwebsoft.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 开发者资源（服务器/数据库/云存储/域名/SSL证书）
+ *
+ * @author 科技小王子
+ * @since 2026-03-31
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("app_resource")
+@Schema(name = "AppResource对象", description = "开发者资源")
+public class AppResource implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "资源ID")
+    @TableId(value = "resource_id", type = IdType.AUTO)
+    private Long resourceId;
+
+    @Schema(description = "资源类型: server/database/storage/domain/ssl")
+    private String resourceType;
+
+    @Schema(description = "资源名称")
+    private String name;
+
+    @Schema(description = "服务商: tencent/aliyun/huawei/other")
+    private String provider;
+
+    @Schema(description = "关联应用ID（可选）")
+    private Long websiteId;
+
+    @Schema(description = "关联应用名称（冗余）")
+    private String websiteName;
+
+    // ─── 服务器字段 ───────────────────────────────────────
+    @Schema(description = "IP地址（服务器用）")
+    private String ip;
+
+    // ─── 数据库字段 ───────────────────────────────────────
+    @Schema(description = "数据库类型: MySQL/PostgreSQL/Redis/MongoDB（数据库用）")
+    private String dbType;
+
+    @Schema(description = "连接主机地址（数据库用）")
+    private String host;
+
+    @Schema(description = "连接端口（数据库用）")
+    private Integer port;
+
+    // ─── 云存储字段 ───────────────────────────────────────
+    @Schema(description = "地区/Region（云存储用）")
+    private String region;
+
+    @Schema(description = "访问权限: public-read/private（云存储用）")
+    private String acl;
+
+    @Schema(description = "已用空间（字节，云存储用）")
+    private Long usedBytes;
+
+    // ─── 域名字段 ─────────────────────────────────────────
+    @Schema(description = "域名（域名用）")
+    private String domain;
+
+    @Schema(description = "注册商（域名用）")
+    private String registrar;
+
+    @Schema(description = "是否已备案（域名用）")
+    private Boolean icp;
+
+    @Schema(description = "ICP备案号（域名用）")
+    private String icpNo;
+
+    @Schema(description = "是否已绑定SSL（域名用，冗余）")
+    private Boolean sslBound;
+
+    // ─── SSL证书字段 ──────────────────────────────────────
+    @Schema(description = "证书类型: DV/OV/EV（SSL用）")
+    private String certType;
+
+    @Schema(description = "颁发机构（SSL用）")
+    private String issuer;
+
+    // ─── 通用字段 ─────────────────────────────────────────
+    @Schema(description = "状态: running/stopped/expired/pending")
+    private String status;
+
+    @Schema(description = "到期时间")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private LocalDate expireAt;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "所属用户ID")
+    private Integer userId;
+
+    @Schema(description = "租户ID")
+    private Integer tenantId;
+
+    @Schema(description = "是否删除: 0否 1是")
+    private Integer deleted;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+    @Schema(description = "更新时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+}

src/main/java/com/gxwebsoft/app/entity/AppTicket.java

@@ -0,0 +1,103 @@
+package com.gxwebsoft.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.gxwebsoft.common.core.config.JsonArrayToStringDeserializer;
+import com.gxwebsoft.common.core.config.JsonStringToArraySerializer;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * 应用工单
+ *
+ * @author 科技小王子
+ * @since 2026-03-30
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("app_ticket")
+@Schema(name = "AppTicket对象", description = "应用工单")
+public class AppTicket implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "工单ID")
+    @TableId(value = "ticket_id", type = IdType.AUTO)
+    private Long ticketId;
+
+    @Schema(description = "工单编号（TK-yyyyMMddHHmmss+4位随机）")
+    private String ticketNo;
+
+    @Schema(description = "工单标题")
+    private String title;
+
+    @Schema(description = "工单内容描述")
+    private String content;
+
+    @Schema(description = "关联应用ID")
+    private Long websiteId;
+
+    @Schema(description = "应用名称（冗余）")
+    private String websiteName;
+
+    @Schema(description = "工单分类: bug/feature/consultation/complaint/other")
+    private String category;
+
+    @Schema(description = "优先级: low/normal/high/urgent")
+    private String priority;
+
+    @Schema(description = "状态: pending/assigned/processing/resolved/closed/rejected")
+    private String status;
+
+    @Schema(description = "附件JSON数组")
+    @JsonDeserialize(using = JsonArrayToStringDeserializer.class)
+    @JsonSerialize(using = JsonStringToArraySerializer.class)
+    private String attachments;
+
+    @Schema(description = "提交人用户ID")
+    private Integer submitUserId;
+
+    @Schema(description = "提交人昵称（冗余）")
+    private String submitUserName;
+
+    @Schema(description = "提交人头像（冗余）")
+    private String submitUserAvatar;
+
+    @Schema(description = "分配的处理人用户ID")
+    private Integer assigneeId;
+
+    @Schema(description = "处理人昵称（冗余）")
+    private String assigneeName;
+
+    @Schema(description = "处理人头像（冗余）")
+    private String assigneeAvatar;
+
+    @Schema(description = "回复数量")
+    private Integer replyCount;
+
+    @Schema(description = "解决时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime resolvedTime;
+
+    @Schema(description = "关闭时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime closedTime;
+
+    @Schema(description = "是否删除: 0否 1是")
+    private Integer deleted;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+    @Schema(description = "更新时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+}

src/main/java/com/gxwebsoft/app/entity/AppTicketReply.java

@@ -0,0 +1,64 @@
+package com.gxwebsoft.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.gxwebsoft.common.core.config.JsonArrayToStringDeserializer;
+import com.gxwebsoft.common.core.config.JsonStringToArraySerializer;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * 工单回复
+ *
+ * @author 科技小王子
+ * @since 2026-03-30
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("app_ticket_reply")
+@Schema(name = "AppTicketReply对象", description = "工单回复")
+public class AppTicketReply implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "回复ID")
+    @TableId(value = "reply_id", type = IdType.AUTO)
+    private Long replyId;
+
+    @Schema(description = "关联工单ID")
+    private Long ticketId;
+
+    @Schema(description = "回复内容")
+    private String content;
+
+    @Schema(description = "附件JSON数组")
+    @JsonDeserialize(using = JsonArrayToStringDeserializer.class)
+    @JsonSerialize(using = JsonStringToArraySerializer.class)
+    private String attachments;
+
+    @Schema(description = "回复人用户ID")
+    private Integer userId;
+
+    @Schema(description = "回复人昵称（冗余）")
+    private String userName;
+
+    @Schema(description = "回复人头像（冗余）")
+    private String userAvatar;
+
+    @Schema(description = "是否是技术人员/客服: 0否 1是")
+    private Integer isStaff;
+
+    @Schema(description = "是否删除: 0否 1是")
+    private Integer deleted;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+}

src/main/java/com/gxwebsoft/app/entity/AppUser.java

@@ -0,0 +1,73 @@
+package com.gxwebsoft.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import java.io.Serializable;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 应用成员
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Schema(name = "AppUser对象", description = "应用成员")
+public class AppUser implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "自增ID")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    @Schema(description = "关联应用ID")
+    private Long websiteId;
+
+    @Schema(description = "用户ID")
+    private Integer userId;
+
+    @Schema(description = "用户名（冗余）")
+    private String username;
+
+    @Schema(description = "昵称（冗余）")
+    private String nickname;
+
+    @Schema(description = "头像（冗余）")
+    private String avatar;
+
+    @Schema(description = "手机号（冗余，脱敏存储）")
+    private String phone;
+
+    @Schema(description = "角色: owner/admin/developer/viewer")
+    private String role;
+
+    @Schema(description = "邀请人用户ID")
+    private Long inviteBy;
+
+    @Schema(description = "加入时间")
+    private LocalDateTime inviteTime;
+
+    @Schema(description = "排序(数字越小越靠前)")
+    private Integer sortNumber;
+
+    @Schema(description = "状态, 0正常, 1冻结")
+    private Integer status;
+
+    @Schema(description = "租户id")
+    private Integer tenantId;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+    @Schema(description = "修改时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+
+}

src/main/java/com/gxwebsoft/app/entity/AppVersion.java

@@ -0,0 +1,85 @@
+package com.gxwebsoft.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import java.io.Serializable;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 应用版本发布记录
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Schema(name = "AppVersion对象", description = "应用版本发布记录")
+public class AppVersion implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "自增ID")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    @Schema(description = "关联应用ID")
+    private Long websiteId;
+
+    @Schema(description = "版本号，如 1.0.0")
+    private String versionNo;
+
+    @Schema(description = "版本名称")
+    private String versionName;
+
+    @Schema(description = "版本更新说明")
+    private String changelog;
+
+    @Schema(description = "安装包地址")
+    private String packageUrl;
+
+    @Schema(description = "包大小(字节)")
+    private Long packageSize;
+
+    @Schema(description = "包MD5/SHA256")
+    private String packageHash;
+
+    @Schema(description = "环境: development/staging/production")
+    private String env;
+
+    @Schema(description = "状态 0=构建中 1=已发布 2=已回滚 3=构建失败")
+    private Integer status;
+
+    @Schema(description = "是否为当前版本")
+    private Boolean isCurrent;
+
+    @Schema(description = "发布人用户ID")
+    private Long publishBy;
+
+    @Schema(description = "发布时间")
+    private LocalDateTime publishTime;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序(数字越小越靠前)")
+    private Integer sortNumber;
+
+    @Schema(description = "用户ID")
+    private Integer userId;
+
+    @Schema(description = "租户id")
+    private Integer tenantId;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+    @Schema(description = "修改时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+
+}

src/main/java/com/gxwebsoft/app/mapper/AppConfigMapper.java

@@ -0,0 +1,43 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.app.entity.AppConfig;
+import com.gxwebsoft.app.param.AppConfigParam;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 应用配置表 Mapper
+ *
+ * @author 科技小王子
+ */
+@Mapper
+public interface AppConfigMapper extends BaseMapper<AppConfig> {
+
+    /**
+     * 批量获取应用配置
+     */
+    List<Map<String, Object>> selectConfigsByWebsiteId(Integer websiteId);
+
+    /**
+     * 分页查询
+     *
+     * @param page  分页对象
+     * @param param 查询参数
+     * @return List<AppConfig>
+     */
+    List<AppConfig> selectPageRel(@Param("page") IPage<AppConfig> page,
+                                   @Param("param") AppConfigParam param);
+
+    /**
+     * 查询全部
+     *
+     * @param param 查询参数
+     * @return List<AppConfig>
+     */
+    List<AppConfig> selectListRel(@Param("param") AppConfigParam param);
+}

src/main/java/com/gxwebsoft/app/mapper/AppCredentialMapper.java

@@ -0,0 +1,37 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.app.entity.AppCredential;
+import com.gxwebsoft.app.param.AppCredentialParam;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 应用密钥凭证Mapper
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:43
+ */
+public interface AppCredentialMapper extends BaseMapper<AppCredential> {
+
+    /**
+     * 分页查询
+     *
+     * @param page  分页对象
+     * @param param 查询参数
+     * @return List<AppCredential>
+     */
+    List<AppCredential> selectPageRel(@Param("page") IPage<AppCredential> page,
+                             @Param("param") AppCredentialParam param);
+
+    /**
+     * 查询全部
+     *
+     * @param param 查询参数
+     * @return List<User>
+     */
+    List<AppCredential> selectListRel(@Param("param") AppCredentialParam param);
+
+}

src/main/java/com/gxwebsoft/app/mapper/AppEventMapper.java

@@ -0,0 +1,37 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.app.entity.AppEvent;
+import com.gxwebsoft.app.param.AppEventParam;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 应用操作动态Mapper
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+public interface AppEventMapper extends BaseMapper<AppEvent> {
+
+    /**
+     * 分页查询
+     *
+     * @param page  分页对象
+     * @param param 查询参数
+     * @return List<AppEvent>
+     */
+    List<AppEvent> selectPageRel(@Param("page") IPage<AppEvent> page,
+                             @Param("param") AppEventParam param);
+
+    /**
+     * 查询全部
+     *
+     * @param param 查询参数
+     * @return List<User>
+     */
+    List<AppEvent> selectListRel(@Param("param") AppEventParam param);
+
+}

src/main/java/com/gxwebsoft/app/mapper/AppResourceMapper.java

@@ -0,0 +1,35 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.app.entity.AppResource;
+import com.gxwebsoft.app.param.AppResourceParam;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 开发者资源 Mapper
+ *
+ * @author 科技小王子
+ * @since 2026-03-31
+ */
+public interface AppResourceMapper extends BaseMapper<AppResource> {
+
+    /**
+     * 分页查询（关联应用名称）
+     */
+    List<AppResource> selectPageRel(@Param("page") IPage<AppResource> page,
+                                    @Param("param") AppResourceParam param);
+
+    /**
+     * 查询全部列表（关联应用名称）
+     */
+    List<AppResource> selectListRel(@Param("param") AppResourceParam param);
+
+    /**
+     * 统计各类型资源数量，返回 [{resourceType, cnt}]
+     */
+    List<java.util.Map<String, Object>> countByType(@Param("userId") Integer userId,
+                                                     @Param("tenantId") Integer tenantId);
+}

src/main/java/com/gxwebsoft/app/mapper/AppTicketMapper.java

@@ -0,0 +1,11 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gxwebsoft.app.entity.AppTicket;
+import org.apache.ibatis.annotations.Param;
+
+/**
+ * 应用工单 Mapper
+ */
+public interface AppTicketMapper extends BaseMapper<AppTicket> {
+}

src/main/java/com/gxwebsoft/app/mapper/AppTicketReplyMapper.java

@@ -0,0 +1,10 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gxwebsoft.app.entity.AppTicketReply;
+
+/**
+ * 工单回复 Mapper
+ */
+public interface AppTicketReplyMapper extends BaseMapper<AppTicketReply> {
+}

src/main/java/com/gxwebsoft/app/mapper/AppUserMapper.java

@@ -0,0 +1,37 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.app.entity.AppUser;
+import com.gxwebsoft.app.param.AppUserParam;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 应用成员Mapper
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+public interface AppUserMapper extends BaseMapper<AppUser> {
+
+    /**
+     * 分页查询
+     *
+     * @param page  分页对象
+     * @param param 查询参数
+     * @return List<AppUser>
+     */
+    List<AppUser> selectPageRel(@Param("page") IPage<AppUser> page,
+                             @Param("param") AppUserParam param);
+
+    /**
+     * 查询全部
+     *
+     * @param param 查询参数
+     * @return List<User>
+     */
+    List<AppUser> selectListRel(@Param("param") AppUserParam param);
+
+}

src/main/java/com/gxwebsoft/app/mapper/AppVersionMapper.java

@@ -0,0 +1,37 @@
+package com.gxwebsoft.app.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.app.entity.AppVersion;
+import com.gxwebsoft.app.param.AppVersionParam;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 应用版本发布记录Mapper
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+public interface AppVersionMapper extends BaseMapper<AppVersion> {
+
+    /**
+     * 分页查询
+     *
+     * @param page  分页对象
+     * @param param 查询参数
+     * @return List<AppVersion>
+     */
+    List<AppVersion> selectPageRel(@Param("page") IPage<AppVersion> page,
+                             @Param("param") AppVersionParam param);
+
+    /**
+     * 查询全部
+     *
+     * @param param 查询参数
+     * @return List<User>
+     */
+    List<AppVersion> selectListRel(@Param("param") AppVersionParam param);
+
+}

src/main/java/com/gxwebsoft/app/mapper/xml/AppConfigMapper.xml

@@ -0,0 +1,66 @@
+<?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.app.mapper.AppConfigMapper">
+
+    <!-- 关联查询sql -->
+    <sql id="selectSql">
+        SELECT a.*
+        FROM app_config a
+        <where>
+            a.deleted = 0
+            <if test="param.configId != null">
+                AND a.config_id = #{param.configId}
+            </if>
+            <if test="param.websiteId != null">
+                AND a.website_id = #{param.websiteId}
+            </if>
+            <if test="param.configKey != null and param.configKey != ''">
+                AND a.config_key LIKE CONCAT('%', #{param.configKey}, '%')
+            </if>
+            <if test="param.configType != null and param.configType != ''">
+                AND a.config_type = #{param.configType}
+            </if>
+            <if test="param.isSecret != null">
+                AND a.is_secret = #{param.isSecret}
+            </if>
+            <if test="param.tenantId != null">
+                AND a.tenant_id = #{param.tenantId}
+            </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 param.keywords != ''">
+                AND a.config_key LIKE CONCAT('%', #{param.keywords}, '%')
+            </if>
+        </where>
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.app.entity.AppConfig">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.app.entity.AppConfig">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 批量获取应用配置（自动解密） -->
+    <select id="selectConfigsByWebsiteId" resultType="java.util.HashMap">
+        SELECT
+            config_key as configKey,
+            config_value as configValue,
+            config_type as configType,
+            is_encrypted as isEncrypted,
+            is_secret as isSecret,
+            description
+        FROM app_config
+        WHERE website_id = #{websiteId}
+          AND deleted = 0
+        ORDER BY config_type, sort_number, config_id
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/app/mapper/xml/AppCredentialMapper.xml

@@ -0,0 +1,71 @@
+<?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.app.mapper.AppCredentialMapper">
+
+    <!-- 关联查询sql -->
+    <sql id="selectSql">
+        SELECT a.*, w.website_name, w.website_code, w.website_icon
+        FROM app_credential a
+        LEFT JOIN cms_website w ON a.website_id = w.website_id AND w.deleted = 0
+        <where>
+            <if test="param.id != null">
+                AND a.id = #{param.id}
+            </if>
+            <if test="param.websiteId != null">
+                AND a.website_id = #{param.websiteId}
+            </if>
+            <if test="param.name != null and param.name != ''">
+                AND a.name LIKE CONCAT('%', #{param.name}, '%')
+            </if>
+            <if test="param.appId != null and param.appId != ''">
+                AND a.app_id = #{param.appId}
+            </if>
+            <if test="param.type != null and param.type != ''">
+                AND a.type = #{param.type}
+            </if>
+            <if test="param.scopes != null and param.scopes != ''">
+                AND a.scopes LIKE CONCAT('%', #{param.scopes}, '%')
+            </if>
+            <if test="param.remark != null and param.remark != ''">
+                AND a.remark LIKE CONCAT('%', #{param.remark}, '%')
+            </if>
+            <if test="param.sortNumber != null">
+                AND a.sort_number = #{param.sortNumber}
+            </if>
+            <if test="param.status != null">
+                AND a.status = #{param.status}
+            </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.userId != null">
+                AND a.user_id = #{param.userId}
+            </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 param.keywords != ''">
+                AND (a.name LIKE CONCAT('%', #{param.keywords}, '%')
+                  OR a.app_id LIKE CONCAT('%', #{param.keywords}, '%')
+                )
+            </if>
+        </where>
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.app.entity.AppCredential">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.app.entity.AppCredential">
+        <include refid="selectSql"></include>
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/app/mapper/xml/AppEventMapper.xml

@@ -0,0 +1,66 @@
+<?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.app.mapper.AppEventMapper">
+
+    <!-- 关联查询sql -->
+    <sql id="selectSql">
+        SELECT a.*, w.website_name, w.website_code, w.website_icon
+        FROM app_event a
+        LEFT JOIN cms_website w ON a.website_id = w.website_id AND w.deleted = 0
+        <where>
+            <if test="param.id != null">
+                AND a.id = #{param.id}
+            </if>
+            <if test="param.websiteId != null">
+                AND a.website_id = #{param.websiteId}
+            </if>
+            <if test="param.eventType != null and param.eventType != ''">
+                AND a.event_type = #{param.eventType}
+            </if>
+            <if test="param.title != null and param.title != ''">
+                AND a.title LIKE CONCAT('%', #{param.title}, '%')
+            </if>
+            <if test="param.operatorId != null">
+                AND a.operator_id = #{param.operatorId}
+            </if>
+            <if test="param.refId != null">
+                AND a.ref_id = #{param.refId}
+            </if>
+            <if test="param.refType != null and param.refType != ''">
+                AND a.ref_type = #{param.refType}
+            </if>
+            <if test="param.status != null">
+                AND a.status = #{param.status}
+            </if>
+            <if test="param.userId != null">
+                AND a.user_id = #{param.userId}
+            </if>
+            <if test="param.tenantId != null">
+                AND a.tenant_id = #{param.tenantId}
+            </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 param.keywords != ''">
+                AND (a.title LIKE CONCAT('%', #{param.keywords}, '%')
+                  OR a.content LIKE CONCAT('%', #{param.keywords}, '%')
+                )
+            </if>
+        </where>
+        ORDER BY a.create_time DESC
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.app.entity.AppEvent">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.app.entity.AppEvent">
+        <include refid="selectSql"></include>
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/app/mapper/xml/AppResourceMapper.xml

@@ -0,0 +1,75 @@
+<?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.app.mapper.AppResourceMapper">
+
+    <!-- 关联查询 SQL -->
+    <sql id="selectSql">
+        SELECT a.*, w.website_name
+        FROM app_resource a
+        LEFT JOIN cms_website w ON a.website_id = w.website_id AND w.deleted = 0
+        <where>
+            a.deleted = 0
+            <if test="param.resourceId != null">
+                AND a.resource_id = #{param.resourceId}
+            </if>
+            <if test="param.resourceType != null and param.resourceType != ''">
+                AND a.resource_type = #{param.resourceType}
+            </if>
+            <if test="param.websiteId != null">
+                AND a.website_id = #{param.websiteId}
+            </if>
+            <if test="param.provider != null and param.provider != ''">
+                AND a.provider = #{param.provider}
+            </if>
+            <if test="param.status != null and param.status != ''">
+                AND a.status = #{param.status}
+            </if>
+            <if test="param.userId != null">
+                AND a.user_id = #{param.userId}
+            </if>
+            <if test="param.tenantId != null">
+                AND a.tenant_id = #{param.tenantId}
+            </if>
+            <if test="param.keywords != null and param.keywords != ''">
+                AND (
+                    a.name        LIKE CONCAT('%', #{param.keywords}, '%')
+                 OR a.ip          LIKE CONCAT('%', #{param.keywords}, '%')
+                 OR a.domain      LIKE CONCAT('%', #{param.keywords}, '%')
+                 OR a.host        LIKE CONCAT('%', #{param.keywords}, '%')
+                )
+            </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>
+        </where>
+        ORDER BY a.create_time DESC
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.app.entity.AppResource">
+        <include refid="selectSql"/>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.app.entity.AppResource">
+        <include refid="selectSql"/>
+    </select>
+
+    <!-- 按类型统计数量 -->
+    <select id="countByType" resultType="java.util.Map">
+        SELECT resource_type AS resourceType, COUNT(*) AS cnt
+        FROM app_resource
+        WHERE deleted = 0
+        <if test="userId != null">
+            AND user_id = #{userId}
+        </if>
+        <if test="tenantId != null">
+            AND tenant_id = #{tenantId}
+        </if>
+        GROUP BY resource_type
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/app/mapper/xml/AppUserMapper.xml

@@ -0,0 +1,62 @@
+<?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.app.mapper.AppUserMapper">
+
+    <!-- 关联查询sql（已移除跨库 JOIN gxwebsoft_core.sys_user，用户信息从冗余字段读取） -->
+    <sql id="selectSql">
+        SELECT a.*, w.website_name, w.website_code, w.website_icon
+        FROM app_user a
+        LEFT JOIN cms_website w ON a.website_id = w.website_id AND w.deleted = 0
+        <where>
+            <if test="param.id != null">
+                AND a.id = #{param.id}
+            </if>
+            <if test="param.websiteId != null">
+                AND a.website_id = #{param.websiteId}
+            </if>
+            <if test="param.userId != null">
+                AND a.user_id = #{param.userId}
+            </if>
+            <if test="param.username != null and param.username != ''">
+                AND (a.username LIKE CONCAT('%', #{param.username}, '%')
+                  OR a.nickname LIKE CONCAT('%', #{param.username}, '%'))
+            </if>
+            <if test="param.role != null and param.role != ''">
+                AND a.role = #{param.role}
+            </if>
+            <if test="param.inviteBy != null">
+                AND a.invite_by = #{param.inviteBy}
+            </if>
+            <if test="param.sortNumber != null">
+                AND a.sort_number = #{param.sortNumber}
+            </if>
+            <if test="param.status != null">
+                AND a.status = #{param.status}
+            </if>
+            <if test="param.tenantId != null">
+                AND a.tenant_id = #{param.tenantId}
+            </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 param.keywords != ''">
+                AND (a.username LIKE CONCAT('%', #{param.keywords}, '%')
+                  OR a.nickname LIKE CONCAT('%', #{param.keywords}, '%'))
+            </if>
+        </where>
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.app.entity.AppUser">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.app.entity.AppUser">
+        <include refid="selectSql"></include>
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/app/mapper/xml/AppVersionMapper.xml

@@ -0,0 +1,66 @@
+<?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.app.mapper.AppVersionMapper">
+
+    <!-- 关联查询sql -->
+    <sql id="selectSql">
+        SELECT a.*, w.website_name, w.website_code, w.website_icon
+        FROM app_version a
+        LEFT JOIN cms_website w ON a.website_id = w.website_id AND w.deleted = 0
+        <where>
+            <if test="param.id != null">
+                AND a.id = #{param.id}
+            </if>
+            <if test="param.websiteId != null">
+                AND a.website_id = #{param.websiteId}
+            </if>
+            <if test="param.versionNo != null and param.versionNo != ''">
+                AND a.version_no = #{param.versionNo}
+            </if>
+            <if test="param.versionName != null and param.versionName != ''">
+                AND a.version_name LIKE CONCAT('%', #{param.versionName}, '%')
+            </if>
+            <if test="param.env != null and param.env != ''">
+                AND a.env = #{param.env}
+            </if>
+            <if test="param.status != null">
+                AND a.status = #{param.status}
+            </if>
+            <if test="param.isCurrent != null">
+                AND a.is_current = #{param.isCurrent}
+            </if>
+            <if test="param.publishBy != null">
+                AND a.publish_by = #{param.publishBy}
+            </if>
+            <if test="param.userId != null">
+                AND a.user_id = #{param.userId}
+            </if>
+            <if test="param.tenantId != null">
+                AND a.tenant_id = #{param.tenantId}
+            </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 param.keywords != ''">
+                AND (a.version_no LIKE CONCAT('%', #{param.keywords}, '%')
+                  OR a.version_name LIKE CONCAT('%', #{param.keywords}, '%')
+                  OR a.changelog LIKE CONCAT('%', #{param.keywords}, '%')
+                )
+            </if>
+        </where>
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.app.entity.AppVersion">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.app.entity.AppVersion">
+        <include refid="selectSql"></include>
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/app/param/AppConfigParam.java

@@ -0,0 +1,38 @@
+package com.gxwebsoft.app.param;
+
+import com.gxwebsoft.common.core.web.BaseParam;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 应用配置表查询参数
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class AppConfigParam extends BaseParam {
+
+    /**
+     * 配置ID
+     */
+    private Integer configId;
+
+    /**
+     * 应用ID
+     */
+    private Integer websiteId;
+
+    /**
+     * 配置键
+     */
+    private String configKey;
+
+    /**
+     * 配置类型
+     */
+    private String configType;
+
+    /**
+     * 是否敏感信息
+     */
+    private Integer isSecret;
+}

src/main/java/com/gxwebsoft/app/param/AppCredentialParam.java

@@ -1,6 +1,5 @@
-package com.gxwebsoft.dormitory.param;
+package com.gxwebsoft.app.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;
@@ -10,60 +9,57 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 
 /**
- * 宿舍床位查询参数
+ * 应用密钥凭证查询参数
  *
  * @author 科技小王子
- * @since 2025-10-03 10:49:27
+ * @since 2026-03-28 21:29:43
  */
 @Data
 @EqualsAndHashCode(callSuper = false)
 @JsonInclude(JsonInclude.Include.NON_NULL)
-@Schema(description = "宿舍床位查询参数")
-public class DormitoryBedParam extends BaseParam {
+@Schema(name = "AppCredentialParam对象", description = "应用密钥凭证查询参数")
+public class AppCredentialParam extends BaseParam {
     private static final long serialVersionUID = 1L;
 
-    @Schema(description = "ID")
+    @Schema(description = "自增ID")
     @QueryField(type = QueryType.EQ)
-    private Integer id;
+    private Long id;
 
-    @Schema(description = "宿舍名称")
+    @Schema(description = "关联应用ID")
+    @QueryField(type = QueryType.EQ)
+    private Long websiteId;
+
+    @Schema(description = "凭证名称，如生产环境密钥")
     private String name;
 
-    @Schema(description = "编号")
-    private String code;
-
-    @Schema(description = "楼栋ID")
+    @Schema(description = "App ID（公开）")
     @QueryField(type = QueryType.EQ)
-    private Integer buildingId;
+    private String appId;
 
-    @Schema(description = "楼层ID")
+    @Schema(description = "凭证类型: server/client/webhook")
     @QueryField(type = QueryType.EQ)
-    private Integer floorId;
+    private String type;
 
-    @Schema(description = "宿舍ID")
-    @QueryField(type = QueryType.EQ)
-    private Integer recordId;
+    @Schema(description = "权限范围，空格分隔")
+    private String scopes;
 
-    @Schema(description = "学生ID")
-    private Integer userId;
-
-    @Schema(description = "上下铺 1下铺 2上铺 0无")
-    @QueryField(type = QueryType.EQ)
-    private Boolean bunk;
-
-    @Schema(description = "充电口")
-    @QueryField(type = QueryType.EQ)
-    private Boolean chargingPort;
+    @Schema(description = "备注")
+    private String remark;
 
     @Schema(description = "排序(数字越小越靠前)")
     @QueryField(type = QueryType.EQ)
     private Integer sortNumber;
 
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "状态, 0正常, 1报修")
+    @Schema(description = "状态, 0正常, 1冻结")
     @QueryField(type = QueryType.EQ)
     private Integer status;
 
+    @Schema(description = "是否删除, 0否, 1是")
+    @QueryField(type = QueryType.EQ)
+    private Integer deleted;
+
+    @Schema(description = "用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
 }

src/main/java/com/gxwebsoft/app/param/AppEventParam.java

@@ -0,0 +1,63 @@
+package com.gxwebsoft.app.param;
+
+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-03-28 21:29:44
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "AppEventParam对象", description = "应用操作动态查询参数")
+public class AppEventParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "自增ID")
+    @QueryField(type = QueryType.EQ)
+    private Long id;
+
+    @Schema(description = "关联应用ID")
+    @QueryField(type = QueryType.EQ)
+    private Long websiteId;
+
+    @Schema(description = "事件类型: created/published/updated/domain_bound/member_added/status_changed")
+    @QueryField(type = QueryType.EQ)
+    private String eventType;
+
+    @Schema(description = "事件标题（模糊）")
+    private String title;
+
+    @Schema(description = "操作人用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Long operatorId;
+
+    @Schema(description = "关联ID，如版本ID")
+    @QueryField(type = QueryType.EQ)
+    private Long refId;
+
+    @Schema(description = "关联类型")
+    @QueryField(type = QueryType.EQ)
+    private String refType;
+
+    @Schema(description = "状态, 0正常, 1冻结")
+    @QueryField(type = QueryType.EQ)
+    private Integer status;
+
+    @Schema(description = "用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "租户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer tenantId;
+
+}

src/main/java/com/gxwebsoft/app/param/AppResourceParam.java

@@ -0,0 +1,54 @@
+package com.gxwebsoft.app.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 2026-03-31
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "AppResourceParam对象", description = "开发者资源查询参数")
+public class AppResourceParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "资源ID")
+    @QueryField(type = QueryType.EQ)
+    private Long resourceId;
+
+    @Schema(description = "资源类型: server/database/storage/domain/ssl")
+    @QueryField(type = QueryType.EQ)
+    private String resourceType;
+
+    @Schema(description = "关联应用ID")
+    @QueryField(type = QueryType.EQ)
+    private Long websiteId;
+
+    @Schema(description = "服务商")
+    @QueryField(type = QueryType.EQ)
+    private String provider;
+
+    @Schema(description = "状态")
+    @QueryField(type = QueryType.EQ)
+    private String status;
+
+    @Schema(description = "所属用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "租户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer tenantId;
+
+    @Schema(description = "关键词（名称/IP/域名/Host模糊搜索）")
+    private String keywords;
+}

src/main/java/com/gxwebsoft/app/param/AppTicketParam.java

@@ -0,0 +1,33 @@
+package com.gxwebsoft.app.param;
+
+import com.gxwebsoft.common.core.web.PageParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 工单查询参数
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Schema(description = "工单查询参数")
+public class AppTicketParam extends PageParam {
+
+    @Schema(description = "关联应用ID")
+    private Long websiteId;
+
+    @Schema(description = "工单状态")
+    private String status;
+
+    @Schema(description = "工单分类")
+    private String category;
+
+    @Schema(description = "优先级")
+    private String priority;
+
+    @Schema(description = "处理人ID（传0=未分配）")
+    private Integer assigneeId;
+
+    @Schema(description = "关键词（标题/工单编号）")
+    private String keywords;
+}

src/main/java/com/gxwebsoft/app/param/AppUserParam.java

@@ -0,0 +1,59 @@
+package com.gxwebsoft.app.param;
+
+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-03-28 21:29:44
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "AppUserParam对象", description = "应用成员查询参数")
+public class AppUserParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "自增ID")
+    @QueryField(type = QueryType.EQ)
+    private Long id;
+
+    @Schema(description = "关联应用ID")
+    @QueryField(type = QueryType.EQ)
+    private Long websiteId;
+
+    @Schema(description = "用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "用户名（模糊搜索）")
+    private String username;
+
+    @Schema(description = "角色: owner/admin/developer/viewer")
+    @QueryField(type = QueryType.EQ)
+    private String role;
+
+    @Schema(description = "邀请人用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Long inviteBy;
+
+    @Schema(description = "排序(数字越小越靠前)")
+    @QueryField(type = QueryType.EQ)
+    private Integer sortNumber;
+
+    @Schema(description = "状态, 0正常, 1冻结")
+    @QueryField(type = QueryType.EQ)
+    private Integer status;
+
+    @Schema(description = "租户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer tenantId;
+
+}

src/main/java/com/gxwebsoft/app/param/AppVersionParam.java

@@ -0,0 +1,63 @@
+package com.gxwebsoft.app.param;
+
+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-03-28 21:29:44
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "AppVersionParam对象", description = "应用版本发布记录查询参数")
+public class AppVersionParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "自增ID")
+    @QueryField(type = QueryType.EQ)
+    private Long id;
+
+    @Schema(description = "关联应用ID")
+    @QueryField(type = QueryType.EQ)
+    private Long websiteId;
+
+    @Schema(description = "版本号，如 1.0.0")
+    @QueryField(type = QueryType.EQ)
+    private String versionNo;
+
+    @Schema(description = "版本名称（模糊）")
+    private String versionName;
+
+    @Schema(description = "环境: development/staging/production")
+    @QueryField(type = QueryType.EQ)
+    private String env;
+
+    @Schema(description = "状态 0=构建中 1=已发布 2=已回滚 3=构建失败")
+    @QueryField(type = QueryType.EQ)
+    private Integer status;
+
+    @Schema(description = "是否为当前版本")
+    @QueryField(type = QueryType.EQ)
+    private Boolean isCurrent;
+
+    @Schema(description = "发布人用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Long publishBy;
+
+    @Schema(description = "用户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "租户ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer tenantId;
+
+}

src/main/java/com/gxwebsoft/app/service/AppConfigService.java

@@ -0,0 +1,58 @@
+package com.gxwebsoft.app.service;
+
+import com.gxwebsoft.app.entity.AppConfig;
+import com.gxwebsoft.app.param.AppConfigParam;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 应用配置表 Service
+ */
+public interface AppConfigService {
+
+    /**
+     * 分页查询应用配置
+     */
+    List<AppConfig> page(AppConfigParam param);
+
+    /**
+     * 获取应用配置列表
+     */
+    List<AppConfig> list(AppConfigParam param);
+
+    /**
+     * 根据应用ID获取配置映射（自动解密）
+     */
+    Map<String, Object> getConfigsByWebsiteId(Integer websiteId);
+
+    /**
+     * 获取单个配置值
+     */
+    String getConfigValue(Integer websiteId, String configKey);
+
+    /**
+     * 保存配置
+     */
+    void saveConfig(AppConfig config);
+
+    /**
+     * 批量保存配置
+     */
+    void batchSaveConfig(Integer websiteId, List<AppConfig> configs);
+
+    /**
+     * 更新配置
+     */
+    void updateConfig(AppConfig config);
+
+    /**
+     * 删除配置
+     */
+    void deleteConfig(Integer configId);
+
+    /**
+     * 根据应用ID删除所有配置
+     */
+    void deleteByWebsiteId(Integer websiteId);
+}

src/main/java/com/gxwebsoft/app/service/AppCredentialService.java

@@ -0,0 +1,57 @@
+package com.gxwebsoft.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.app.entity.AppCredential;
+import com.gxwebsoft.app.param.AppCredentialParam;
+
+import java.util.List;
+
+/**
+ * 应用密钥凭证Service
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:43
+ */
+public interface AppCredentialService extends IService<AppCredential> {
+
+    /**
+     * 分页关联查询
+     */
+    PageResult<AppCredential> pageRel(AppCredentialParam param);
+
+    /**
+     * 关联查询全部
+     */
+    List<AppCredential> listRel(AppCredentialParam param);
+
+    /**
+     * 根据id查询
+     */
+    AppCredential getByIdRel(Integer id);
+
+    /**
+     * 创建凭证（自动生成 appId 和 appSecret）
+     *
+     * @param credential 凭证基础信息
+     * @return 包含明文 appSecret 的凭证对象（仅此次返回，之后不再展示）
+     */
+    AppCredential createCredential(AppCredential credential);
+
+    /**
+     * 重置密钥（重新生成 appSecret）
+     *
+     * @param id 凭证ID
+     * @return 包含新明文 appSecret 的凭证对象
+     */
+    AppCredential resetSecret(Long id);
+
+    /**
+     * 禁用/启用凭证
+     *
+     * @param id     凭证ID
+     * @param status 0=正常 1=冻结
+     */
+    boolean updateStatus(Long id, Integer status);
+
+}

src/main/java/com/gxwebsoft/app/service/AppEventService.java

@@ -0,0 +1,60 @@
+package com.gxwebsoft.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.app.entity.AppEvent;
+import com.gxwebsoft.app.param.AppEventParam;
+
+import java.util.List;
+
+/**
+ * 应用操作动态Service
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+public interface AppEventService extends IService<AppEvent> {
+
+    /**
+     * 分页关联查询
+     */
+    PageResult<AppEvent> pageRel(AppEventParam param);
+
+    /**
+     * 关联查询全部
+     */
+    List<AppEvent> listRel(AppEventParam param);
+
+    /**
+     * 根据id查询
+     */
+    AppEvent getByIdRel(Integer id);
+
+    /**
+     * 记录应用事件（便捷方法，供其他模块调用）
+     *
+     * @param websiteId  应用ID
+     * @param eventType  事件类型（created/published/updated/domain_bound/member_added/status_changed 等）
+     * @param title      事件标题
+     * @param content    详细描述
+     * @param operatorId 操作人用户ID
+     * @param operatorName 操作人名称
+     * @param refId      关联记录ID（如版本ID）
+     * @param refType    关联记录类型
+     */
+    void logEvent(Long websiteId, String eventType, String title, String content,
+                  Long operatorId, String operatorName, Long refId, String refType);
+
+    /**
+     * 快捷记录事件（无关联记录）
+     */
+    void logEvent(Long websiteId, String eventType, String title, Long operatorId, String operatorName);
+
+    /**
+     * 获取指定应用的最新一条事件（用于卡片"最新动态"展示）
+     *
+     * @param websiteId 应用ID
+     */
+    AppEvent getLatestEvent(Long websiteId);
+
+}

src/main/java/com/gxwebsoft/app/service/AppResourceService.java

@@ -0,0 +1,39 @@
+package com.gxwebsoft.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.app.entity.AppResource;
+import com.gxwebsoft.app.param.AppResourceParam;
+import com.gxwebsoft.common.core.web.PageResult;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 开发者资源 Service
+ *
+ * @author 科技小王子
+ * @since 2026-03-31
+ */
+public interface AppResourceService extends IService<AppResource> {
+
+    /** 分页查询（关联应用名称） */
+    PageResult<AppResource> pageRel(AppResourceParam param);
+
+    /** 列表查询 */
+    List<AppResource> listRel(AppResourceParam param);
+
+    /** 详情（关联查询） */
+    AppResource getByIdRel(Long resourceId);
+
+    /** 新增资源 */
+    AppResource addResource(AppResource resource, Integer userId);
+
+    /** 更新资源 */
+    AppResource updateResource(AppResource resource);
+
+    /** 删除资源（逻辑删除） */
+    void removeResource(Long resourceId, Integer userId);
+
+    /** 按资源类型统计数量 [{resourceType, cnt}] */
+    Map<String, Long> countByType(Integer userId, Integer tenantId);
+}

src/main/java/com/gxwebsoft/app/service/AppTicketService.java

@@ -0,0 +1,46 @@
+package com.gxwebsoft.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.app.entity.AppTicket;
+import com.gxwebsoft.app.entity.AppTicketReply;
+import com.gxwebsoft.app.param.AppTicketParam;
+import com.gxwebsoft.common.core.web.PageResult;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 应用工单 Service
+ */
+public interface AppTicketService extends IService<AppTicket> {
+
+    /** 客户端：查自己提交的工单（分页） */
+    PageResult<AppTicket> myPage(AppTicketParam param, Integer userId);
+
+    /** 技术端：查询所有工单（分页） */
+    PageResult<AppTicket> allPage(AppTicketParam param);
+
+    /** 提交工单（自动分配） */
+    AppTicket submit(AppTicket ticket, Integer userId);
+
+    /** 更新状态（技术人员操作） */
+    void updateStatus(Long ticketId, String status, Integer operatorId);
+
+    /** 分配处理人 */
+    void assign(Long ticketId, Integer assigneeId);
+
+    /** 关闭工单（提交人操作） */
+    void closeByUser(Long ticketId, Integer userId);
+
+    /** 获取工单回复列表 */
+    List<AppTicketReply> getReplies(Long ticketId);
+
+    /** 添加回复 */
+    AppTicketReply addReply(AppTicketReply reply, Integer userId);
+
+    /** 统计数据 */
+    Map<String, Long> stats(Long websiteId, Integer userId);
+
+    /** 获取技术人员列表（角色：developer/admin 的应用成员） */
+    List<Map<String, Object>> getTechStaffList();
+}

src/main/java/com/gxwebsoft/app/service/AppUserService.java

@@ -0,0 +1,68 @@
+package com.gxwebsoft.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.app.entity.AppUser;
+import com.gxwebsoft.app.param.AppUserParam;
+
+import java.util.List;
+
+/**
+ * 应用成员Service
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+public interface AppUserService extends IService<AppUser> {
+
+    /**
+     * 分页关联查询
+     */
+    PageResult<AppUser> pageRel(AppUserParam param);
+
+    /**
+     * 关联查询全部
+     */
+    List<AppUser> listRel(AppUserParam param);
+
+    /**
+     * 根据id查询
+     */
+    AppUser getByIdRel(Integer id);
+
+    /**
+     * 邀请成员加入应用
+     *
+     * @param websiteId 应用ID
+     * @param userId    被邀请的用户ID
+     * @param role      分配的角色
+     * @param inviteBy  邀请人用户ID
+     * @return 成员记录
+     */
+    AppUser inviteUser(Long websiteId, Integer userId, String role, Integer inviteBy);
+
+    /**
+     * 修改成员角色
+     *
+     * @param id   成员记录ID
+     * @param role 新角色
+     */
+    boolean updateRole(Long id, String role);
+
+    /**
+     * 检查用户是否已是应用成员
+     *
+     * @param websiteId 应用ID
+     * @param userId    用户ID
+     */
+    boolean isMember(Long websiteId, Integer userId);
+
+    /**
+     * 根据手机号查找系统用户（用于手机号邀请）
+     *
+     * @param phone 手机号
+     * @return 系统用户，不存在返回 null
+     */
+    com.gxwebsoft.common.system.entity.User findUserByPhone(String phone);
+
+}

src/main/java/com/gxwebsoft/app/service/AppVersionService.java

@@ -0,0 +1,56 @@
+package com.gxwebsoft.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.app.entity.AppVersion;
+import com.gxwebsoft.app.param.AppVersionParam;
+
+import java.util.List;
+
+/**
+ * 应用版本发布记录Service
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+public interface AppVersionService extends IService<AppVersion> {
+
+    /**
+     * 分页关联查询
+     */
+    PageResult<AppVersion> pageRel(AppVersionParam param);
+
+    /**
+     * 关联查询全部
+     */
+    List<AppVersion> listRel(AppVersionParam param);
+
+    /**
+     * 根据id查询
+     */
+    AppVersion getByIdRel(Integer id);
+
+    /**
+     * 发布版本（将此版本设为当前版本，其他版本 isCurrent=false）
+     *
+     * @param id       版本ID
+     * @param publishBy 发布人用户ID
+     */
+    boolean publish(Long id, Integer publishBy);
+
+    /**
+     * 回滚到指定版本（将此版本设为当前版本，当前版本标为已回滚）
+     *
+     * @param id       要回滚到的版本ID
+     * @param publishBy 操作人用户ID
+     */
+    boolean rollback(Long id, Integer publishBy);
+
+    /**
+     * 获取指定应用的当前版本
+     *
+     * @param websiteId 应用ID
+     */
+    AppVersion getCurrentVersion(Long websiteId);
+
+}

src/main/java/com/gxwebsoft/app/service/impl/AppConfigServiceImpl.java

@@ -0,0 +1,270 @@
+package com.gxwebsoft.app.service.impl;
+
+import cn.hutool.crypto.SecureUtil;
+import cn.hutool.crypto.symmetric.AES;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.app.entity.AppConfig;
+import com.gxwebsoft.app.mapper.AppConfigMapper;
+import com.gxwebsoft.app.param.AppConfigParam;
+import com.gxwebsoft.app.service.AppConfigService;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.system.entity.User;
+import com.gxwebsoft.common.system.service.UserService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 应用配置表 Service 实现类
+ *
+ * @author 科技小王子
+ */
+@Slf4j
+@Service
+public class AppConfigServiceImpl extends ServiceImpl<AppConfigMapper, AppConfig> implements AppConfigService {
+
+    @Resource
+    private UserService userService;
+
+    /**
+     * 配置加密密钥（从配置文件读取）
+     */
+    @Value("${app.config.encrypt-key:GXWebsoft2024!@#$}")
+    private String encryptKey;
+
+    /**
+     * 分页查询应用配置
+     */
+    @Override
+    public List<AppConfig> page(AppConfigParam param) {
+        PageParam<AppConfig, AppConfigParam> page = new PageParam<>(param);
+        page.setDefaultOrder("sort_number asc, config_id asc");
+        List<AppConfig> list = baseMapper.selectPageRel(page, param);
+        return page.sortRecords(list);
+    }
+
+    /**
+     * 分页查询应用配置（返回PageResult）
+     */
+    public PageResult<AppConfig> pageRel(AppConfigParam param) {
+        PageParam<AppConfig, AppConfigParam> page = new PageParam<>(param);
+        page.setDefaultOrder("sort_number asc, config_id asc");
+        List<AppConfig> list = baseMapper.selectPageRel(page, param);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    /**
+     * 获取应用配置列表
+     */
+    @Override
+    public List<AppConfig> list(AppConfigParam param) {
+        List<AppConfig> list = baseMapper.selectListRel(param);
+        PageParam<AppConfig, AppConfigParam> page = new PageParam<>();
+        page.setDefaultOrder("sort_number asc, config_id asc");
+        return page.sortRecords(list);
+    }
+
+    /**
+     * 根据应用ID获取配置映射（自动解密）
+     */
+    @Override
+    public Map<String, Object> getConfigsByWebsiteId(Integer websiteId) {
+        List<Map<String, Object>> configs = baseMapper.selectConfigsByWebsiteId(websiteId);
+        Map<String, Object> result = new HashMap<>();
+
+        for (Map<String, Object> config : configs) {
+            String configKey = (String) config.get("configKey");
+            Object configValue = config.get("configValue");
+            Integer isEncrypted = (Integer) config.get("isEncrypted");
+
+            // 解密
+            if (isEncrypted != null && isEncrypted == 1 && configValue != null) {
+                try {
+                    configValue = decrypt((String) configValue);
+                } catch (Exception e) {
+                    log.error("配置解密失败: {}", configKey, e);
+                }
+            }
+
+            result.put(configKey, configValue);
+        }
+
+        return result;
+    }
+
+    /**
+     * 获取单个配置值
+     */
+    @Override
+    public String getConfigValue(Integer websiteId, String configKey) {
+        LambdaQueryWrapper<AppConfig> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(AppConfig::getWebsiteId, websiteId);
+        wrapper.eq(AppConfig::getConfigKey, configKey);
+        AppConfig config = getOne(wrapper);
+
+        if (config == null || config.getConfigValue() == null) {
+            return null;
+        }
+
+        // 解密
+        if (config.getIsEncrypted() != null && config.getIsEncrypted() == 1) {
+            return decrypt(config.getConfigValue());
+        }
+
+        return config.getConfigValue();
+    }
+
+    /**
+     * 保存配置
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void saveConfig(AppConfig config) {
+        // 设置租户ID
+        Integer tenantId = getCurrentTenantId();
+        if (tenantId != null) {
+            config.setTenantId(Long.valueOf(tenantId));
+        }
+
+        // 加密敏感信息
+        if (config.getIsEncrypted() != null && config.getIsEncrypted() == 1 && config.getConfigValue() != null) {
+            config.setConfigValue(encrypt(config.getConfigValue()));
+        }
+
+        save(config);
+    }
+
+    /**
+     * 批量保存配置
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void batchSaveConfig(Integer websiteId, List<AppConfig> configs) {
+        // 设置租户ID
+        Integer tenantId = getCurrentTenantId();
+        if (tenantId != null) {
+            for (AppConfig config : configs) {
+                config.setTenantId(Long.valueOf(tenantId));
+            }
+        }
+
+        // 先删除该应用的所有配置
+        remove(new LambdaQueryWrapper<AppConfig>()
+                .eq(AppConfig::getWebsiteId, websiteId));
+
+        // 批量插入新配置
+        for (AppConfig config : configs) {
+            config.setWebsiteId(websiteId);
+
+            // 加密敏感信息
+            if (config.getIsEncrypted() != null && config.getIsEncrypted() == 1 && config.getConfigValue() != null) {
+                config.setConfigValue(encrypt(config.getConfigValue()));
+            }
+
+            save(config);
+        }
+    }
+
+    /**
+     * 更新配置
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void updateConfig(AppConfig config) {
+        // 加密敏感信息
+        if (config.getIsEncrypted() != null && config.getIsEncrypted() == 1 && config.getConfigValue() != null) {
+            config.setConfigValue(encrypt(config.getConfigValue()));
+        }
+
+        updateById(config);
+    }
+
+    /**
+     * 删除配置
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteConfig(Integer configId) {
+        removeById(configId);
+    }
+
+    /**
+     * 根据应用ID删除所有配置
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteByWebsiteId(Integer websiteId) {
+        remove(new LambdaQueryWrapper<AppConfig>()
+                .eq(AppConfig::getWebsiteId, websiteId));
+    }
+
+    /**
+     * 构建查询条件
+     */
+    private LambdaQueryWrapper<AppConfig> buildQueryWrapper(AppConfigParam param) {
+        LambdaQueryWrapper<AppConfig> wrapper = new LambdaQueryWrapper<>();
+
+        if (param.getConfigId() != null) {
+            wrapper.eq(AppConfig::getConfigId, param.getConfigId());
+        }
+        if (param.getWebsiteId() != null) {
+            wrapper.eq(AppConfig::getWebsiteId, param.getWebsiteId());
+        }
+        if (param.getConfigKey() != null) {
+            wrapper.like(AppConfig::getConfigKey, param.getConfigKey());
+        }
+        if (param.getConfigType() != null) {
+            wrapper.eq(AppConfig::getConfigType, param.getConfigType());
+        }
+        if (param.getIsSecret() != null) {
+            wrapper.eq(AppConfig::getIsSecret, param.getIsSecret());
+        }
+
+        wrapper.orderByAsc(AppConfig::getConfigType)
+               .orderByAsc(AppConfig::getSortNumber)
+               .orderByAsc(AppConfig::getConfigId);
+
+        return wrapper;
+    }
+
+    /**
+     * AES 加密
+     */
+    private String encrypt(String plainText) {
+        AES aes = SecureUtil.aes(encryptKey.getBytes());
+        return aes.encryptBase64(plainText);
+    }
+
+    /**
+     * AES 解密
+     */
+    private String decrypt(String cipherText) {
+        AES aes = SecureUtil.aes(encryptKey.getBytes());
+        return aes.decryptStr(cipherText);
+    }
+
+    /**
+     * 获取当前登录用户的租户ID
+     */
+    private Integer getCurrentTenantId() {
+        try {
+            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+            if (authentication != null && authentication.getPrincipal() instanceof User) {
+                return ((User) authentication.getPrincipal()).getTenantId();
+            }
+        } catch (Exception e) {
+            log.error("获取当前用户租户ID失败", e);
+        }
+        return null;
+    }
+}

src/main/java/com/gxwebsoft/app/service/impl/AppCredentialServiceImpl.java

@@ -0,0 +1,125 @@
+package com.gxwebsoft.app.service.impl;
+
+import cn.hutool.core.util.RandomUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.app.mapper.AppCredentialMapper;
+import com.gxwebsoft.app.service.AppCredentialService;
+import com.gxwebsoft.app.entity.AppCredential;
+import com.gxwebsoft.app.param.AppCredentialParam;
+import com.gxwebsoft.common.core.utils.CommonUtil;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 应用密钥凭证Service实现
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:43
+ */
+@Slf4j
+@Service
+public class AppCredentialServiceImpl extends ServiceImpl<AppCredentialMapper, AppCredential> implements AppCredentialService {
+
+    @Override
+    public PageResult<AppCredential> pageRel(AppCredentialParam param) {
+        PageParam<AppCredential, AppCredentialParam> page = new PageParam<>(param);
+        page.setDefaultOrder("sort_number asc, create_time desc");
+        List<AppCredential> list = baseMapper.selectPageRel(page, param);
+        // 脱敏处理：appSecret 不对外展示（仅创建/重置时返回明文）
+        list.forEach(this::maskSecret);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    @Override
+    public List<AppCredential> listRel(AppCredentialParam param) {
+        List<AppCredential> list = baseMapper.selectListRel(param);
+        PageParam<AppCredential, AppCredentialParam> page = new PageParam<>();
+        page.setDefaultOrder("sort_number asc, create_time desc");
+        list = page.sortRecords(list);
+        list.forEach(this::maskSecret);
+        return list;
+    }
+
+    @Override
+    public AppCredential getByIdRel(Integer id) {
+        AppCredentialParam param = new AppCredentialParam();
+        param.setId(id.longValue());
+        AppCredential credential = param.getOne(baseMapper.selectListRel(param));
+        if (credential != null) {
+            maskSecret(credential);
+        }
+        return credential;
+    }
+
+    @Override
+    public AppCredential createCredential(AppCredential credential) {
+        // 生成 AppID：app_ + 16位随机字符串
+        String appId = "app_" + CommonUtil.randomUUID16();
+        // 生成 AppSecret：32位随机字符串（大小写字母+数字）
+        String appSecret = generateSecretValue();
+
+        credential.setAppId(appId);
+        credential.setAppSecret(appSecret);
+        // 默认状态正常
+        if (credential.getStatus() == null) {
+            credential.setStatus(0);
+        }
+        if (StrUtil.isBlank(credential.getType())) {
+            credential.setType("server");
+        }
+
+        save(credential);
+        log.info("创建凭证成功，websiteId={}, appId={}", credential.getWebsiteId(), appId);
+        // 返回含明文 secret 的对象（仅此一次）
+        return credential;
+    }
+
+    @Override
+    public AppCredential resetSecret(Long id) {
+        AppCredential credential = getById(id);
+        if (credential == null) {
+            throw new RuntimeException("凭证不存在");
+        }
+        String newSecret = generateSecretValue();
+        credential.setAppSecret(newSecret);
+        updateById(credential);
+        log.info("重置凭证密钥成功，id={}", id);
+        return credential;
+    }
+
+    @Override
+    public boolean updateStatus(Long id, Integer status) {
+        return update(new LambdaUpdateWrapper<AppCredential>()
+                .eq(AppCredential::getId, id)
+                .set(AppCredential::getStatus, status));
+    }
+
+    /**
+     * 生成32位随机 AppSecret
+     */
+    private String generateSecretValue() {
+        // 格式：8位-8位-8位-8位（类似 UUID 格式，便于复制）
+        return RandomUtil.randomString(8) + "-"
+                + RandomUtil.randomString(8) + "-"
+                + RandomUtil.randomString(8) + "-"
+                + RandomUtil.randomString(8);
+    }
+
+    /**
+     * 脱敏处理：将 appSecret 替换为掩码
+     */
+    private void maskSecret(AppCredential credential) {
+        if (StrUtil.isNotBlank(credential.getAppSecret())) {
+            // 只保留前4位，其余用 * 替代
+            String secret = credential.getAppSecret();
+            credential.setAppSecret(secret.substring(0, Math.min(4, secret.length())) + "**********************");
+        }
+    }
+
+}

src/main/java/com/gxwebsoft/app/service/impl/AppEventServiceImpl.java

@@ -0,0 +1,86 @@
+package com.gxwebsoft.app.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.app.mapper.AppEventMapper;
+import com.gxwebsoft.app.service.AppEventService;
+import com.gxwebsoft.app.entity.AppEvent;
+import com.gxwebsoft.app.param.AppEventParam;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 应用操作动态Service实现
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Slf4j
+@Service
+public class AppEventServiceImpl extends ServiceImpl<AppEventMapper, AppEvent> implements AppEventService {
+
+    @Override
+    public PageResult<AppEvent> pageRel(AppEventParam param) {
+        PageParam<AppEvent, AppEventParam> page = new PageParam<>(param);
+        page.setDefaultOrder("create_time desc");
+        List<AppEvent> list = baseMapper.selectPageRel(page, param);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    @Override
+    public List<AppEvent> listRel(AppEventParam param) {
+        List<AppEvent> list = baseMapper.selectListRel(param);
+        PageParam<AppEvent, AppEventParam> page = new PageParam<>();
+        page.setDefaultOrder("create_time desc");
+        return page.sortRecords(list);
+    }
+
+    @Override
+    public AppEvent getByIdRel(Integer id) {
+        AppEventParam param = new AppEventParam();
+        param.setId(id.longValue());
+        return param.getOne(baseMapper.selectListRel(param));
+    }
+
+    @Override
+    @Async
+    public void logEvent(Long websiteId, String eventType, String title, String content,
+                         Long operatorId, String operatorName, Long refId, String refType) {
+        try {
+            AppEvent event = new AppEvent();
+            event.setWebsiteId(websiteId);
+            event.setEventType(eventType);
+            event.setTitle(title);
+            event.setContent(content);
+            event.setOperatorId(operatorId);
+            event.setOperator(operatorName);
+            event.setRefId(refId);
+            event.setRefType(refType);
+            event.setStatus(0);
+            save(event);
+            log.debug("记录事件成功，websiteId={}, eventType={}, title={}", websiteId, eventType, title);
+        } catch (Exception e) {
+            log.warn("记录事件失败，websiteId={}, eventType={}: {}", websiteId, eventType, e.getMessage());
+        }
+    }
+
+    @Override
+    @Async
+    public void logEvent(Long websiteId, String eventType, String title, Long operatorId, String operatorName) {
+        logEvent(websiteId, eventType, title, null, operatorId, operatorName, null, null);
+    }
+
+    @Override
+    public AppEvent getLatestEvent(Long websiteId) {
+        return getOne(new LambdaQueryWrapper<AppEvent>()
+                .eq(AppEvent::getWebsiteId, websiteId)
+                .orderByDesc(AppEvent::getCreateTime)
+                .last("LIMIT 1"));
+    }
+
+}

src/main/java/com/gxwebsoft/app/service/impl/AppResourceServiceImpl.java

@@ -0,0 +1,109 @@
+package com.gxwebsoft.app.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.app.entity.AppResource;
+import com.gxwebsoft.app.mapper.AppResourceMapper;
+import com.gxwebsoft.app.param.AppResourceParam;
+import com.gxwebsoft.app.service.AppResourceService;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 开发者资源 Service 实现
+ *
+ * @author 科技小王子
+ * @since 2026-03-31
+ */
+@Slf4j
+@Service
+public class AppResourceServiceImpl extends ServiceImpl<AppResourceMapper, AppResource>
+        implements AppResourceService {
+
+    @Override
+    public PageResult<AppResource> pageRel(AppResourceParam param) {
+        PageParam<AppResource, AppResourceParam> page = new PageParam<>(param);
+        page.setDefaultOrder("create_time desc");
+        List<AppResource> list = baseMapper.selectPageRel(page, param);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    @Override
+    public List<AppResource> listRel(AppResourceParam param) {
+        return baseMapper.selectListRel(param);
+    }
+
+    @Override
+    public AppResource getByIdRel(Long resourceId) {
+        AppResourceParam param = new AppResourceParam();
+        param.setResourceId(resourceId);
+        List<AppResource> list = baseMapper.selectListRel(param);
+        return list.isEmpty() ? null : list.get(0);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AppResource addResource(AppResource resource, Integer userId) {
+        resource.setUserId(userId);
+        resource.setDeleted(0);
+        resource.setCreateTime(LocalDateTime.now());
+        resource.setUpdateTime(LocalDateTime.now());
+        // 默认状态
+        if (resource.getStatus() == null) {
+            resource.setStatus("running");
+        }
+        save(resource);
+        log.info("新增资源成功, type={}, name={}, userId={}", resource.getResourceType(), resource.getName(), userId);
+        return resource;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AppResource updateResource(AppResource resource) {
+        if (resource.getResourceId() == null) {
+            throw new RuntimeException("资源ID不能为空");
+        }
+        resource.setUpdateTime(LocalDateTime.now());
+        updateById(resource);
+        return getByIdRel(resource.getResourceId());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void removeResource(Long resourceId, Integer userId) {
+        AppResource resource = getById(resourceId);
+        if (resource == null) {
+            throw new RuntimeException("资源不存在");
+        }
+        if (!resource.getUserId().equals(userId)) {
+            throw new RuntimeException("无权操作此资源");
+        }
+        resource.setDeleted(1);
+        resource.setUpdateTime(LocalDateTime.now());
+        updateById(resource);
+        log.info("删除资源成功, resourceId={}, userId={}", resourceId, userId);
+    }
+
+    @Override
+    public Map<String, Long> countByType(Integer userId, Integer tenantId) {
+        List<Map<String, Object>> raw = baseMapper.countByType(userId, tenantId);
+        Map<String, Long> result = new HashMap<>();
+        // 初始化所有类型为 0
+        for (String type : new String[]{"server", "database", "storage", "domain", "ssl"}) {
+            result.put(type, 0L);
+        }
+        for (Map<String, Object> row : raw) {
+            String type = (String) row.get("resourceType");
+            Long cnt = ((Number) row.get("cnt")).longValue();
+            result.put(type, cnt);
+        }
+        return result;
+    }
+}

src/main/java/com/gxwebsoft/app/service/impl/AppTicketServiceImpl.java

@@ -0,0 +1,579 @@
+package com.gxwebsoft.app.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HttpUtil;
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.app.entity.AppTicket;
+import com.gxwebsoft.app.entity.AppTicketReply;
+import com.gxwebsoft.app.entity.AppUser;
+import com.gxwebsoft.app.mapper.AppTicketMapper;
+import com.gxwebsoft.app.mapper.AppTicketReplyMapper;
+import com.gxwebsoft.app.param.AppTicketParam;
+import com.gxwebsoft.app.service.AppTicketService;
+import com.gxwebsoft.app.service.AppUserService;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.system.entity.User;
+import com.gxwebsoft.common.system.service.UserService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 应用工单 Service 实现
+ *
+ * @author 科技小王子
+ * @since 2026-03-30
+ */
+@Slf4j
+@Service
+public class AppTicketServiceImpl extends ServiceImpl<AppTicketMapper, AppTicket> implements AppTicketService {
+
+    /** 企业微信群机器人 Webhook，留空则不发送 */
+    @Value("${notify.wecom-webhook:}")
+    private String wecomWebhook;
+
+    /** 飞书群机器人 Webhook，留空则不发送 */
+    @Value("${notify.feishu-webhook:}")
+    private String feishuWebhook;
+
+    @Resource
+    private AppTicketReplyMapper replyMapper;
+
+    @Resource
+    private AppUserService appUserService;
+
+    @Resource
+    private UserService userService;
+
+    // ─── 生成工单编号 ─────────────────────────────────────────────
+    private String generateTicketNo() {
+        String ts = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
+        String rand = String.format("%04d", new Random().nextInt(10000));
+        return "TK-" + ts + rand;
+    }
+
+    // ─── 客户端：查自己的工单 ─────────────────────────────────────
+    @Override
+    public PageResult<AppTicket> myPage(AppTicketParam param, Integer userId) {
+        // 用 PageParam 包装分页参数（getCurrent/getSize 来自父类 Page<T>）
+        Page<AppTicket> page = new Page<>(param.getCurrent(), param.getSize() > 0 ? param.getSize() : 15);
+
+        LambdaQueryWrapper<AppTicket> wrapper = new LambdaQueryWrapper<AppTicket>()
+                .eq(AppTicket::getDeleted, 0)
+                .eq(AppTicket::getSubmitUserId, userId)
+                .eq(ObjectUtil.isNotNull(param.getWebsiteId()), AppTicket::getWebsiteId, param.getWebsiteId())
+                .eq(ObjectUtil.isNotEmpty(param.getStatus()), AppTicket::getStatus, param.getStatus())
+                .eq(ObjectUtil.isNotEmpty(param.getCategory()), AppTicket::getCategory, param.getCategory())
+                .and(ObjectUtil.isNotEmpty(param.getKeywords()), q ->
+                        q.like(AppTicket::getTitle, param.getKeywords())
+                         .or().like(AppTicket::getTicketNo, param.getKeywords()))
+                // 状态优先级：pending > assigned > processing > resolved > closed；同状态内最新的排前
+                .last("ORDER BY FIELD(status,'pending','assigned','processing','resolved','closed','rejected'), create_time DESC");
+
+        baseMapper.selectPage(page, wrapper);
+        return new PageResult<>(page.getRecords(), page.getTotal());
+    }
+
+    // ─── 技术端：查所有工单 ───────────────────────────────────────
+    @Override
+    public PageResult<AppTicket> allPage(AppTicketParam param) {
+        Page<AppTicket> page = new Page<>(param.getCurrent(), param.getSize() > 0 ? param.getSize() : 20);
+
+        LambdaQueryWrapper<AppTicket> wrapper = new LambdaQueryWrapper<AppTicket>()
+                .eq(AppTicket::getDeleted, 0)
+                .eq(ObjectUtil.isNotNull(param.getWebsiteId()), AppTicket::getWebsiteId, param.getWebsiteId())
+                .eq(ObjectUtil.isNotEmpty(param.getStatus()), AppTicket::getStatus, param.getStatus())
+                .eq(ObjectUtil.isNotEmpty(param.getCategory()), AppTicket::getCategory, param.getCategory())
+                .eq(ObjectUtil.isNotEmpty(param.getPriority()), AppTicket::getPriority, param.getPriority())
+                .and(ObjectUtil.isNotNull(param.getAssigneeId()) && param.getAssigneeId() == 0,
+                        q -> q.isNull(AppTicket::getAssigneeId))
+                .eq(ObjectUtil.isNotNull(param.getAssigneeId()) && param.getAssigneeId() > 0,
+                        AppTicket::getAssigneeId, param.getAssigneeId())
+                .and(ObjectUtil.isNotEmpty(param.getKeywords()), q ->
+                        q.like(AppTicket::getTitle, param.getKeywords())
+                         .or().like(AppTicket::getTicketNo, param.getKeywords()))
+                // 状态优先级 > 紧急程度 > 最新提交时间
+                .last("ORDER BY FIELD(status,'pending','assigned','processing','resolved','closed','rejected'), FIELD(priority,'urgent','high','normal','low'), create_time DESC");
+
+        baseMapper.selectPage(page, wrapper);
+        return new PageResult<>(page.getRecords(), page.getTotal());
+    }
+
+    // ─── 提交工单（自动分配） ─────────────────────────────────────
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AppTicket submit(AppTicket ticket, Integer userId) {
+        // 补充提交人信息
+        ticket.setSubmitUserId(userId);
+        ticket.setTicketNo(generateTicketNo());
+        ticket.setStatus("pending");
+        ticket.setReplyCount(0);
+        ticket.setDeleted(0);
+        ticket.setCreateTime(LocalDateTime.now());
+        ticket.setUpdateTime(LocalDateTime.now());
+
+        // 从用户服务取昵称/头像冗余存储（@InterceptorIgnore 绕过租户拦截器跨库查询）
+        try {
+            User user = userService.getByIdIgnoreTenant(userId);
+            if (user != null) {
+                ticket.setSubmitUserName(user.getNickname() != null ? user.getNickname() : user.getUsername());
+                ticket.setSubmitUserAvatar(user.getAvatar());
+            }
+        } catch (Exception e) {
+            log.warn("获取提交人信息失败", e);
+        }
+
+        // 自动分配：查找该应用的 admin/developer 成员，随机分配
+        autoAssign(ticket);
+
+        save(ticket);
+
+        // 异步推送：新工单通知（通知分配到的技术人员）
+        sendTicketCreatedAsync(ticket);
+
+        return ticket;
+    }
+
+    /** 自动分配工单给应用的技术成员 */
+    private void autoAssign(AppTicket ticket) {
+        if (ticket.getWebsiteId() == null) return;
+        try {
+            List<AppUser> members = appUserService.list(
+                    new LambdaQueryWrapper<AppUser>()
+                            .eq(AppUser::getWebsiteId, ticket.getWebsiteId())
+                            .eq(AppUser::getStatus, 0)
+                            .in(AppUser::getRole, "admin", "developer", "owner"));
+            if (!members.isEmpty()) {
+                // 简单轮询：按工单数最少分配（此处随机）
+                AppUser assigned = members.get(new Random().nextInt(members.size()));
+                ticket.setAssigneeId(assigned.getUserId());
+                ticket.setAssigneeName(assigned.getNickname() != null ? assigned.getNickname() : assigned.getUsername());
+                ticket.setAssigneeAvatar(assigned.getAvatar());
+                ticket.setStatus("assigned");
+            }
+        } catch (Exception e) {
+            log.warn("自动分配工单失败，保持 pending 状态", e);
+        }
+    }
+
+    // ─── 更新状态 ─────────────────────────────────────────────────
+    @Override
+    public void updateStatus(Long ticketId, String status, Integer operatorId) {
+        LambdaUpdateWrapper<AppTicket> wrapper = new LambdaUpdateWrapper<AppTicket>()
+                .eq(AppTicket::getTicketId, ticketId)
+                .set(AppTicket::getStatus, status)
+                .set(AppTicket::getUpdateTime, LocalDateTime.now());
+        if ("resolved".equals(status)) {
+            wrapper.set(AppTicket::getResolvedTime, LocalDateTime.now());
+            // 如果没有分配人，自动将操作人设为处理人
+            AppTicket t = getById(ticketId);
+            if (t != null && t.getAssigneeId() == null) {
+                wrapper.set(AppTicket::getAssigneeId, operatorId);
+            }
+        }
+        update(wrapper);
+
+        // 异步推送：状态变更通知提交人（已解决/已关闭）
+        if ("resolved".equals(status) || "closed".equals(status)) {
+            AppTicket t = getById(ticketId);
+            if (t != null) sendStatusChangedAsync(t, status);
+        }
+    }
+
+    // ─── 分配处理人 ───────────────────────────────────────────────
+    @Override
+    public void assign(Long ticketId, Integer assigneeId) {
+        User user = userService.getByIdIgnoreTenant(assigneeId);
+        LambdaUpdateWrapper<AppTicket> wrapper = new LambdaUpdateWrapper<AppTicket>()
+                .eq(AppTicket::getTicketId, ticketId)
+                .set(AppTicket::getAssigneeId, assigneeId)
+                .set(user != null, AppTicket::getAssigneeName,
+                        user != null ? (user.getNickname() != null ? user.getNickname() : user.getUsername()) : null)
+                .set(user != null, AppTicket::getAssigneeAvatar, user != null ? user.getAvatar() : null)
+                .set(AppTicket::getStatus, "assigned")
+                .set(AppTicket::getUpdateTime, LocalDateTime.now());
+        update(wrapper);
+
+        // 异步推送：通知新分配到的技术人员
+        AppTicket t = getById(ticketId);
+        if (t != null) sendTicketAssignedAsync(t);
+    }
+
+    // ─── 用户关闭工单 ─────────────────────────────────────────────
+    @Override
+    public void closeByUser(Long ticketId, Integer userId) {
+        AppTicket ticket = getById(ticketId);
+        if (ticket == null || !ticket.getSubmitUserId().equals(userId)) {
+            throw new RuntimeException("无权操作该工单");
+        }
+        update(new LambdaUpdateWrapper<AppTicket>()
+                .eq(AppTicket::getTicketId, ticketId)
+                .set(AppTicket::getStatus, "closed")
+                .set(AppTicket::getClosedTime, LocalDateTime.now())
+                .set(AppTicket::getUpdateTime, LocalDateTime.now()));
+    }
+
+    // ─── 获取回复列表 ─────────────────────────────────────────────
+    @Override
+    public List<AppTicketReply> getReplies(Long ticketId) {
+        return replyMapper.selectList(
+                new LambdaQueryWrapper<AppTicketReply>()
+                        .eq(AppTicketReply::getTicketId, ticketId)
+                        .eq(AppTicketReply::getDeleted, 0)
+                        .orderByAsc(AppTicketReply::getCreateTime));
+    }
+
+    // ─── 添加回复 ─────────────────────────────────────────────────
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AppTicketReply addReply(AppTicketReply reply, Integer userId) {
+        reply.setUserId(userId);
+        reply.setDeleted(0);
+        reply.setCreateTime(LocalDateTime.now());
+
+        // 补充用户信息（@InterceptorIgnore 绕过租户拦截器跨库查询）
+        try {
+            User user = userService.getByIdIgnoreTenant(userId);
+            if (user != null) {
+                reply.setUserName(user.getNickname() != null ? user.getNickname() : user.getUsername());
+                reply.setUserAvatar(user.getAvatar());
+            }
+        } catch (Exception e) {
+            log.warn("获取回复人信息失败", e);
+        }
+
+        // 判断是否是技术人员（该应用的 admin/developer/owner）
+        AppTicket ticket = getById(reply.getTicketId());
+        if (ticket != null) {
+            boolean isStaff = appUserService.count(new LambdaQueryWrapper<AppUser>()
+                    .eq(AppUser::getWebsiteId, ticket.getWebsiteId())
+                    .eq(AppUser::getUserId, userId)
+                    .in(AppUser::getRole, "owner", "admin", "developer")
+                    .eq(AppUser::getStatus, 0)) > 0;
+            reply.setIsStaff(isStaff ? 1 : 0);
+        } else {
+            reply.setIsStaff(0);
+        }
+
+        replyMapper.insert(reply);
+
+        // 更新工单回复数 & 更新时间，若状态是 assigned 则推进为 processing
+        update(new LambdaUpdateWrapper<AppTicket>()
+                .eq(AppTicket::getTicketId, reply.getTicketId())
+                .setSql("reply_count = reply_count + 1")
+                .set(AppTicket::getUpdateTime, LocalDateTime.now())
+                .eq(AppTicket::getStatus, "assigned")
+                .set(AppTicket::getStatus, "processing"));
+
+        // 异步推送：有新回复时通知对方
+        if (ticket != null) sendReplyNotifyAsync(ticket, reply);
+
+        return reply;
+    }
+
+    // ─── 统计 ─────────────────────────────────────────────────────
+    @Override
+    public Map<String, Long> stats(Long websiteId, Integer userId) {
+        LambdaQueryWrapper<AppTicket> base = new LambdaQueryWrapper<AppTicket>()
+                .eq(AppTicket::getDeleted, 0)
+                .eq(ObjectUtil.isNotNull(websiteId), AppTicket::getWebsiteId, websiteId)
+                .eq(ObjectUtil.isNotNull(userId), AppTicket::getSubmitUserId, userId);
+
+        Map<String, Long> result = new HashMap<>();
+        result.put("total", (long) count(base.clone()));
+        result.put("pending", (long) count(base.clone().in(AppTicket::getStatus, "pending", "assigned")));
+        result.put("processing", (long) count(base.clone().eq(AppTicket::getStatus, "processing")));
+        result.put("resolved", (long) count(base.clone().eq(AppTicket::getStatus, "resolved")));
+        result.put("closed", (long) count(base.clone().eq(AppTicket::getStatus, "closed")));
+        return result;
+    }
+
+    // ─── 获取技术人员列表 ─────────────────────────────────────────
+    @Override
+    public List<Map<String, Object>> getTechStaffList() {
+        List<AppUser> members = appUserService.list(
+                new LambdaQueryWrapper<AppUser>()
+                        .eq(AppUser::getStatus, 0)
+                        .in(AppUser::getRole, "owner", "admin", "developer")
+                        .select(AppUser::getUserId, AppUser::getNickname, AppUser::getAvatar));
+
+        // 去重（一个用户可能在多个应用里）
+        Map<Integer, AppUser> dedupMap = new LinkedHashMap<>();
+        for (AppUser m : members) {
+            dedupMap.put(m.getUserId(), m);
+        }
+
+        return dedupMap.values().stream().map(m -> {
+            Map<String, Object> map = new HashMap<>();
+            map.put("userId", m.getUserId());
+            map.put("nickname", m.getNickname() != null ? m.getNickname() : "用户" + m.getUserId());
+            map.put("avatar", m.getAvatar());
+            return map;
+        }).collect(Collectors.toList());
+    }
+
+    // ════════════════════════════════════════════════════════════
+    //  异步消息推送
+    // ════════════════════════════════════════════════════════════
+
+    /**
+     * 场景1：新工单提交 → 通知分配到的技术人员
+     */
+    @Async
+    public void sendTicketCreatedAsync(AppTicket ticket) {
+        String now = now();
+        String title = String.format("🎫 新工单待处理（%s）", now);
+
+        String assigneeLine = StrUtil.isNotBlank(ticket.getAssigneeName())
+                ? "**处理人：** " + ticket.getAssigneeName()
+                : "**处理人：** 待分配";
+
+        String wecomContent = String.format(
+                "## %s\n" +
+                "> **工单号：** %s\n" +
+                "> **标题：** %s\n" +
+                "> **分类：** %s  **优先级：** %s\n" +
+                "> **提交人：** %s\n" +
+                "> %s\n" +
+                "> **描述：** %s",
+                title,
+                nullSafe(ticket.getTicketNo()),
+                nullSafe(ticket.getTitle()),
+                categoryLabel(ticket.getCategory()), priorityLabel(ticket.getPriority()),
+                nullSafe(ticket.getSubmitUserName()),
+                assigneeLine,
+                truncate(ticket.getContent(), 120)
+        );
+
+        List<String[]> feishuLines = Arrays.asList(
+                new String[]{"工单号：" + nullSafe(ticket.getTicketNo())},
+                new String[]{"标　题：" + nullSafe(ticket.getTitle())},
+                new String[]{"分　类：" + categoryLabel(ticket.getCategory()) + "  优先级：" + priorityLabel(ticket.getPriority())},
+                new String[]{"提交人：" + nullSafe(ticket.getSubmitUserName())},
+                new String[]{assigneeLine.replace("**", "")},
+                new String[]{"描　述：" + truncate(ticket.getContent(), 120)}
+        );
+
+        doSend(title, wecomContent, feishuLines, "ticket_created");
+    }
+
+    /**
+     * 场景2：工单被重新分配 → 通知新处理人
+     */
+    @Async
+    public void sendTicketAssignedAsync(AppTicket ticket) {
+        String now = now();
+        String title = String.format("📋 工单已分配给您（%s）", now);
+
+        String wecomContent = String.format(
+                "## %s\n" +
+                "> **工单号：** %s\n" +
+                "> **标题：** %s\n" +
+                "> **分配给：** <font color=\"warning\">%s</font>\n" +
+                "> **分类：** %s  **优先级：** %s\n" +
+                "> **描述：** %s",
+                title,
+                nullSafe(ticket.getTicketNo()),
+                nullSafe(ticket.getTitle()),
+                nullSafe(ticket.getAssigneeName()),
+                categoryLabel(ticket.getCategory()), priorityLabel(ticket.getPriority()),
+                truncate(ticket.getContent(), 100)
+        );
+
+        List<String[]> feishuLines = Arrays.asList(
+                new String[]{"工单号：" + nullSafe(ticket.getTicketNo())},
+                new String[]{"标　题：" + nullSafe(ticket.getTitle())},
+                new String[]{"分配给：" + nullSafe(ticket.getAssigneeName())},
+                new String[]{"分　类：" + categoryLabel(ticket.getCategory()) + "  优先级：" + priorityLabel(ticket.getPriority())},
+                new String[]{"描　述：" + truncate(ticket.getContent(), 100)}
+        );
+
+        doSend(title, wecomContent, feishuLines, "ticket_assigned");
+    }
+
+    /**
+     * 场景3：有新回复 → 技术人员回复则通知客户，客户回复则通知技术人员
+     */
+    @Async
+    public void sendReplyNotifyAsync(AppTicket ticket, AppTicketReply reply) {
+        boolean isStaff = Integer.valueOf(1).equals(reply.getIsStaff());
+        String now = now();
+        String who = isStaff ? "技术人员" : "用户";
+        String notifyRole = isStaff ? "您的工单有新回复" : "工单有用户新回复";
+        String title = String.format("💬 %s（%s）", notifyRole, now);
+
+        String wecomContent = String.format(
+                "## %s\n" +
+                "> **工单号：** %s\n" +
+                "> **标题：** %s\n" +
+                "> **回复人：** %s（%s）\n" +
+                "> **回复内容：** %s",
+                title,
+                nullSafe(ticket.getTicketNo()),
+                nullSafe(ticket.getTitle()),
+                nullSafe(reply.getUserName()), who,
+                truncate(reply.getContent(), 200)
+        );
+
+        List<String[]> feishuLines = Arrays.asList(
+                new String[]{"工单号：" + nullSafe(ticket.getTicketNo())},
+                new String[]{"标　题：" + nullSafe(ticket.getTitle())},
+                new String[]{"回复人：" + nullSafe(reply.getUserName()) + "（" + who + "）"},
+                new String[]{"回复内容：" + truncate(reply.getContent(), 200)}
+        );
+
+        doSend(title, wecomContent, feishuLines, "ticket_reply");
+    }
+
+    /**
+     * 场景4：状态变更（已解决/已关闭）→ 通知提交人
+     */
+    @Async
+    public void sendStatusChangedAsync(AppTicket ticket, String status) {
+        String now = now();
+        String emoji = "resolved".equals(status) ? "✅" : "🔒";
+        String statusLabel = "resolved".equals(status) ? "已解决" : "已关闭";
+        String title = String.format("%s 工单%s（%s）", emoji, statusLabel, now);
+
+        String wecomContent = String.format(
+                "## %s\n" +
+                "> **工单号：** %s\n" +
+                "> **标题：** %s\n" +
+                "> **提交人：** %s\n" +
+                "> **处理人：** %s\n" +
+                "> **状态：** <font color=\"%s\">%s</font>",
+                title,
+                nullSafe(ticket.getTicketNo()),
+                nullSafe(ticket.getTitle()),
+                nullSafe(ticket.getSubmitUserName()),
+                nullSafe(ticket.getAssigneeName()),
+                "resolved".equals(status) ? "info" : "comment",
+                statusLabel
+        );
+
+        List<String[]> feishuLines = Arrays.asList(
+                new String[]{"工单号：" + nullSafe(ticket.getTicketNo())},
+                new String[]{"标　题：" + nullSafe(ticket.getTitle())},
+                new String[]{"提交人：" + nullSafe(ticket.getSubmitUserName())},
+                new String[]{"处理人：" + nullSafe(ticket.getAssigneeName())},
+                new String[]{"状　态：" + statusLabel}
+        );
+
+        doSend(title, wecomContent, feishuLines, "ticket_status");
+    }
+
+    /**
+     * 统一发送入口：企业微信 + 飞书
+     */
+    private void doSend(String title, String wecomContent, List<String[]> feishuLines, String scene) {
+        if (StrUtil.isNotBlank(wecomWebhook)) {
+            try {
+                sendWecom(wecomContent);
+            } catch (Exception e) {
+                log.warn("[工单通知][{}] 企业微信发送失败: {}", scene, e.getMessage());
+            }
+        }
+        if (StrUtil.isNotBlank(feishuWebhook)) {
+            try {
+                sendFeishu(title, feishuLines);
+            } catch (Exception e) {
+                log.warn("[工单通知][{}] 飞书发送失败: {}", scene, e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * 企业微信群机器人 - markdown 消息
+     * 文档：https://developer.work.weixin.qq.com/document/path/91770
+     */
+    private void sendWecom(String content) {
+        Map<String, Object> textMap = new HashMap<>();
+        textMap.put("content", content);
+        Map<String, Object> payload = new HashMap<>();
+        payload.put("msgtype", "markdown");
+        payload.put("markdown", textMap);
+        String resp = HttpUtil.post(wecomWebhook, JSON.toJSONString(payload));
+        log.info("[工单通知] 企业微信推送结果: {}", resp);
+    }
+
+    /**
+     * 飞书群机器人 - 富文本（post）消息
+     * 文档：https://open.feishu.cn/document/client-docs/bot-v3/add-custom-bot
+     */
+    private void sendFeishu(String title, List<String[]> lines) {
+        List<List<Map<String, String>>> content = new ArrayList<>();
+        for (String[] line : lines) {
+            Map<String, String> node = new HashMap<>();
+            node.put("tag", "text");
+            node.put("text", line[0]);
+            content.add(Collections.singletonList(node));
+        }
+
+        Map<String, Object> zhCn = new HashMap<>();
+        zhCn.put("title", title);
+        zhCn.put("content", content);
+        Map<String, Object> postContent = new HashMap<>();
+        postContent.put("zh_cn", zhCn);
+        Map<String, Object> post = new HashMap<>();
+        post.put("content", postContent);
+        Map<String, Object> payload = new HashMap<>();
+        payload.put("msg_type", "post");
+        payload.put("content", post);
+
+        String resp = HttpUtil.post(feishuWebhook, JSON.toJSONString(payload));
+        log.info("[工单通知] 飞书推送结果: {}", resp);
+    }
+
+    // ════════════════════════════════════════════════════════════
+    //  工具方法
+    // ════════════════════════════════════════════════════════════
+
+    private String now() {
+        return LocalDateTime.now().format(DateTimeFormatter.ofPattern("MM-dd HH:mm"));
+    }
+
+    private String nullSafe(String s) {
+        return StrUtil.isBlank(s) ? "—" : s;
+    }
+
+    private String truncate(String s, int max) {
+        if (StrUtil.isBlank(s)) return "—";
+        return s.length() > max ? s.substring(0, max) + "…" : s;
+    }
+
+    private String categoryLabel(String category) {
+        if (category == null) return "其他";
+        return switch (category) {
+            case "bug" -> "Bug反馈";
+            case "feature" -> "功能需求";
+            case "config" -> "配置问题";
+            case "performance" -> "性能问题";
+            case "security" -> "安全问题";
+            default -> category;
+        };
+    }
+
+    private String priorityLabel(String priority) {
+        if (priority == null) return "普通";
+        return switch (priority) {
+            case "urgent" -> "🔴 紧急";
+            case "high" -> "🟠 高";
+            case "normal" -> "🟡 普通";
+            case "low" -> "🟢 低";
+            default -> priority;
+        };
+    }
+}

src/main/java/com/gxwebsoft/app/service/impl/AppUserServiceImpl.java

@@ -0,0 +1,112 @@
+package com.gxwebsoft.app.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.app.mapper.AppUserMapper;
+import com.gxwebsoft.app.service.AppUserService;
+import com.gxwebsoft.app.entity.AppUser;
+import com.gxwebsoft.app.param.AppUserParam;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.system.entity.User;
+import com.gxwebsoft.common.system.service.UserService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 应用成员Service实现
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Slf4j
+@Service
+public class AppUserServiceImpl extends ServiceImpl<AppUserMapper, AppUser> implements AppUserService {
+
+    /** 注入同 jar 包内的 UserService，用于写入冗余用户信息，不做跨库 JOIN */
+    @Resource
+    private UserService userService;
+
+    @Override
+    public PageResult<AppUser> pageRel(AppUserParam param) {
+        PageParam<AppUser, AppUserParam> page = new PageParam<>(param);
+        page.setDefaultOrder("sort_number asc, create_time asc");
+        List<AppUser> list = baseMapper.selectPageRel(page, param);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    @Override
+    public List<AppUser> listRel(AppUserParam param) {
+        List<AppUser> list = baseMapper.selectListRel(param);
+        PageParam<AppUser, AppUserParam> page = new PageParam<>();
+        page.setDefaultOrder("sort_number asc, create_time asc");
+        return page.sortRecords(list);
+    }
+
+    @Override
+    public AppUser getByIdRel(Integer id) {
+        AppUserParam param = new AppUserParam();
+        param.setId(id.longValue());
+        return param.getOne(baseMapper.selectListRel(param));
+    }
+
+    @Override
+    public AppUser inviteUser(Long websiteId, Integer userId, String role, Integer inviteBy) {
+        // 检查是否已经是成员
+        if (isMember(websiteId, userId)) {
+            throw new RuntimeException("该用户已经是应用成员");
+        }
+
+        // 查询用户基础信息并冗余写入，避免跨库 JOIN
+        User sysUser = userService.getByIdIgnoreTenant(userId);
+        if (sysUser == null) {
+            throw new RuntimeException("用户不存在，userId=" + userId);
+        }
+
+        AppUser appUser = new AppUser();
+        appUser.setWebsiteId(websiteId);
+        appUser.setUserId(userId);
+        appUser.setRole(role != null ? role : "developer");
+        appUser.setInviteBy(inviteBy.longValue());
+        appUser.setInviteTime(LocalDateTime.now());
+        appUser.setStatus(0);
+        appUser.setSortNumber(0);
+        // 冗余写入用户基础信息，彻底解除跨库 JOIN 依赖
+        appUser.setUsername(sysUser.getUsername());
+        appUser.setNickname(sysUser.getNickname());
+        appUser.setAvatar(sysUser.getAvatar());
+        appUser.setPhone(sysUser.getPhone());
+
+        save(appUser);
+        log.info("邀请成员成功，websiteId={}, userId={}, username={}, role={}", websiteId, userId, sysUser.getUsername(), role);
+        return appUser;
+    }
+
+    @Override
+    public boolean updateRole(Long id, String role) {
+        return update(new LambdaUpdateWrapper<AppUser>()
+                .eq(AppUser::getId, id)
+                .set(AppUser::getRole, role));
+    }
+
+    @Override
+    public boolean isMember(Long websiteId, Integer userId) {
+        long count = count(new LambdaQueryWrapper<AppUser>()
+                .eq(AppUser::getWebsiteId, websiteId)
+                .eq(AppUser::getUserId, userId)
+                .eq(AppUser::getStatus, 0));
+        return count > 0;
+    }
+
+    @Override
+    public User findUserByPhone(String phone) {
+        return userService.getByPhone(phone);
+    }
+
+}

src/main/java/com/gxwebsoft/app/service/impl/AppVersionServiceImpl.java

@@ -0,0 +1,112 @@
+package com.gxwebsoft.app.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.app.mapper.AppVersionMapper;
+import com.gxwebsoft.app.service.AppVersionService;
+import com.gxwebsoft.app.entity.AppVersion;
+import com.gxwebsoft.app.param.AppVersionParam;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 应用版本发布记录Service实现
+ *
+ * @author 科技小王子
+ * @since 2026-03-28 21:29:44
+ */
+@Slf4j
+@Service
+public class AppVersionServiceImpl extends ServiceImpl<AppVersionMapper, AppVersion> implements AppVersionService {
+
+    @Override
+    public PageResult<AppVersion> pageRel(AppVersionParam param) {
+        PageParam<AppVersion, AppVersionParam> page = new PageParam<>(param);
+        page.setDefaultOrder("create_time desc");
+        List<AppVersion> list = baseMapper.selectPageRel(page, param);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    @Override
+    public List<AppVersion> listRel(AppVersionParam param) {
+        List<AppVersion> list = baseMapper.selectListRel(param);
+        PageParam<AppVersion, AppVersionParam> page = new PageParam<>();
+        page.setDefaultOrder("create_time desc");
+        return page.sortRecords(list);
+    }
+
+    @Override
+    public AppVersion getByIdRel(Integer id) {
+        AppVersionParam param = new AppVersionParam();
+        param.setId(id.longValue());
+        return param.getOne(baseMapper.selectListRel(param));
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean publish(Long id, Integer publishBy) {
+        AppVersion version = getById(id);
+        if (version == null) {
+            throw new RuntimeException("版本不存在");
+        }
+        Long websiteId = version.getWebsiteId();
+
+        // 1. 将该应用下所有版本的 isCurrent 设为 false
+        update(new LambdaUpdateWrapper<AppVersion>()
+                .eq(AppVersion::getWebsiteId, websiteId)
+                .set(AppVersion::getIsCurrent, false));
+
+        // 2. 将当前版本设为已发布+当前版本
+        version.setStatus(1);
+        version.setIsCurrent(true);
+        version.setPublishBy(publishBy.longValue());
+        version.setPublishTime(LocalDateTime.now());
+
+        boolean result = updateById(version);
+        log.info("发布版本成功，id={}, versionNo={}", id, version.getVersionNo());
+        return result;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean rollback(Long id, Integer publishBy) {
+        AppVersion targetVersion = getById(id);
+        if (targetVersion == null) {
+            throw new RuntimeException("目标版本不存在");
+        }
+        Long websiteId = targetVersion.getWebsiteId();
+
+        // 1. 将当前版本标记为已回滚
+        update(new LambdaUpdateWrapper<AppVersion>()
+                .eq(AppVersion::getWebsiteId, websiteId)
+                .eq(AppVersion::getIsCurrent, true)
+                .set(AppVersion::getStatus, 2)       // 2=已回滚
+                .set(AppVersion::getIsCurrent, false));
+
+        // 2. 将目标版本设为当前版本
+        targetVersion.setStatus(1);
+        targetVersion.setIsCurrent(true);
+        targetVersion.setPublishBy(publishBy.longValue());
+        targetVersion.setPublishTime(LocalDateTime.now());
+
+        boolean result = updateById(targetVersion);
+        log.info("回滚版本成功，id={}, versionNo={}", id, targetVersion.getVersionNo());
+        return result;
+    }
+
+    @Override
+    public AppVersion getCurrentVersion(Long websiteId) {
+        return getOne(new LambdaQueryWrapper<AppVersion>()
+                .eq(AppVersion::getWebsiteId, websiteId)
+                .eq(AppVersion::getIsCurrent, true)
+                .last("LIMIT 1"));
+    }
+
+}

src/main/java/com/gxwebsoft/app/sql/app_resource.sql

@@ -0,0 +1,54 @@
+-- ----------------------------
+-- 开发者资源管理表
+-- 统一存放服务器/数据库/云存储/域名/SSL证书等开发基础设施资源
+-- ----------------------------
+CREATE TABLE IF NOT EXISTS `app_resource` (
+  `resource_id`   BIGINT        NOT NULL AUTO_INCREMENT     COMMENT '资源ID',
+  `resource_type` VARCHAR(20)   NOT NULL                    COMMENT '资源类型: server/database/storage/domain/ssl',
+  `name`          VARCHAR(100)  NOT NULL                    COMMENT '资源名称',
+  `provider`      VARCHAR(30)   DEFAULT NULL                COMMENT '服务商: tencent/aliyun/huawei/other',
+
+  -- 服务器字段
+  `ip`            VARCHAR(50)   DEFAULT NULL                COMMENT 'IP地址（服务器用）',
+
+  -- 数据库字段
+  `db_type`       VARCHAR(30)   DEFAULT NULL                COMMENT '数据库类型: MySQL/PostgreSQL/Redis/MongoDB',
+  `host`          VARCHAR(200)  DEFAULT NULL                COMMENT '连接主机地址（数据库用）',
+  `port`          INT           DEFAULT NULL                COMMENT '连接端口（数据库用）',
+
+  -- 云存储字段
+  `region`        VARCHAR(50)   DEFAULT NULL                COMMENT '地区/Region（云存储用）',
+  `acl`           VARCHAR(30)   DEFAULT 'private'           COMMENT '访问权限: public-read/private（云存储用）',
+  `used_bytes`    BIGINT        DEFAULT 0                   COMMENT '已用空间（字节，云存储用）',
+
+  -- 域名字段
+  `domain`        VARCHAR(200)  DEFAULT NULL                COMMENT '域名（域名/SSL用）',
+  `registrar`     VARCHAR(100)  DEFAULT NULL                COMMENT '注册商（域名用）',
+  `icp`           TINYINT(1)    DEFAULT 0                   COMMENT '是否已备案: 0否 1是（域名用）',
+  `icp_no`        VARCHAR(100)  DEFAULT NULL                COMMENT 'ICP备案号（域名用）',
+  `ssl_bound`     TINYINT(1)    DEFAULT 0                   COMMENT '是否已绑定SSL（域名冗余标记）',
+
+  -- SSL证书字段
+  `cert_type`     VARCHAR(10)   DEFAULT NULL                COMMENT '证书类型: DV/OV/EV（SSL用）',
+  `issuer`        VARCHAR(100)  DEFAULT NULL                COMMENT '颁发机构（SSL用）',
+
+  -- 通用字段
+  `status`        VARCHAR(20)   NOT NULL DEFAULT 'running'  COMMENT '状态: running/stopped/expired/pending',
+  `website_id`    BIGINT        DEFAULT NULL                COMMENT '关联应用ID（可选）',
+  `expire_at`     DATE          DEFAULT NULL                COMMENT '到期时间',
+  `remark`        VARCHAR(500)  DEFAULT NULL                COMMENT '备注',
+  `user_id`       INT           NOT NULL                    COMMENT '所属用户ID',
+  `tenant_id`     INT           DEFAULT NULL                COMMENT '租户ID',
+  `deleted`       TINYINT       NOT NULL DEFAULT 0          COMMENT '是否删除: 0否 1是',
+  `create_time`   DATETIME      DEFAULT CURRENT_TIMESTAMP   COMMENT '创建时间',
+  `update_time`   DATETIME      DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+
+  PRIMARY KEY (`resource_id`),
+  KEY `idx_resource_type` (`resource_type`),
+  KEY `idx_user_id` (`user_id`),
+  KEY `idx_tenant_id` (`tenant_id`),
+  KEY `idx_website_id` (`website_id`),
+  KEY `idx_status` (`status`),
+  KEY `idx_expire_at` (`expire_at`),
+  KEY `idx_deleted` (`deleted`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='开发者资源管理（服务器/数据库/云存储/域名/SSL）';

src/main/java/com/gxwebsoft/auto/controller/QrLoginController.java

@@ -1,104 +0,0 @@
-package com.gxwebsoft.auto.controller;
-
-import com.gxwebsoft.auto.dto.QrLoginConfirmRequest;
-import com.gxwebsoft.auto.dto.QrLoginGenerateResponse;
-import com.gxwebsoft.auto.dto.QrLoginStatusResponse;
-import com.gxwebsoft.auto.service.QrLoginService;
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.common.core.web.ApiResult;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.Parameter;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
-
-import javax.validation.Valid;
-
-/**
- * 认证模块
- *
- * @author 科技小王子
- * @since 2025-03-06 22:50:25
- */
-@Tag(name = "认证模块")
-@RestController
-@RequestMapping("/api/qr-login")
-public class QrLoginController extends BaseController {
-
-    @Autowired
-    private QrLoginService qrLoginService;
-
-    /**
-     * 生成扫码登录token
-     */
-    @Operation(summary = "生成扫码登录token")
-    @PostMapping("/generate")
-    public ApiResult<?> generateQrLoginToken() {
-        try {
-            QrLoginGenerateResponse response = qrLoginService.generateQrLoginToken();
-            return success("生成成功", response);
-        } catch (Exception e) {
-            return fail(e.getMessage());
-        }
-    }
-
-    /**
-     * 检查扫码登录状态
-     */
-    @Operation(summary = "检查扫码登录状态")
-    @GetMapping("/status/{token}")
-    public ApiResult<?> checkQrLoginStatus(
-            @Parameter(description = "扫码登录token") @PathVariable String token) {
-        try {
-            QrLoginStatusResponse response = qrLoginService.checkQrLoginStatus(token);
-            return success("查询成功", response);
-        } catch (Exception e) {
-            return fail(e.getMessage());
-        }
-    }
-
-    /**
-     * 确认扫码登录
-     */
-    @Operation(summary = "确认扫码登录")
-    @PostMapping("/confirm")
-    public ApiResult<?> confirmQrLogin(@Valid @RequestBody QrLoginConfirmRequest request) {
-        try {
-            QrLoginStatusResponse response = qrLoginService.confirmQrLogin(request);
-            return success("确认成功", response);
-        } catch (Exception e) {
-            return fail(e.getMessage());
-        }
-    }
-
-    /**
-     * 扫码操作(可选接口，用于移动端扫码后更新状态)
-     */
-    @Operation(summary = "扫码操作")
-    @PostMapping("/scan/{token}")
-    public ApiResult<?> scanQrCode(@Parameter(description = "扫码登录token") @PathVariable String token) {
-        try {
-            boolean result = qrLoginService.scanQrCode(token);
-            return success("操作成功", result);
-        } catch (Exception e) {
-            return fail(e.getMessage());
-        }
-    }
-
-    /**
-     * 微信小程序扫码登录确认(便捷接口)
-     */
-    @Operation(summary = "微信小程序扫码登录确认")
-    @PostMapping("/wechat-confirm")
-    public ApiResult<?> wechatMiniProgramConfirm(@Valid @RequestBody QrLoginConfirmRequest request) {
-        try {
-            // 设置平台为微信小程序
-            request.setPlatform("miniprogram");
-            QrLoginStatusResponse response = qrLoginService.confirmQrLogin(request);
-            return success("微信小程序登录确认成功", response);
-        } catch (Exception e) {
-            return fail(e.getMessage());
-        }
-    }
-
-}

src/main/java/com/gxwebsoft/auto/dto/QrLoginConfirmRequest.java

@@ -1,50 +0,0 @@
-package com.gxwebsoft.auto.dto;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-
-import javax.validation.constraints.NotBlank;
-
-/**
- * 扫码登录确认请求
- *
- * @author 科技小王子
- * @since 2025-08-31
- */
-@Data
-@Schema(description = "扫码登录确认请求")
-public class QrLoginConfirmRequest {
-
-    @Schema(description = "扫码登录token")
-    @NotBlank(message = "token不能为空")
-    private String token;
-
-    @Schema(description = "用户ID")
-    private Integer userId;
-
-    @Schema(description = "登录平台: web-网页端, app-移动应用, miniprogram-微信小程序")
-    private String platform;
-
-    @Schema(description = "微信小程序相关信息")
-    private WechatMiniProgramInfo wechatInfo;
-
-    /**
-     * 微信小程序信息
-     */
-    @Data
-    @Schema(description = "微信小程序信息")
-    public static class WechatMiniProgramInfo {
-        @Schema(description = "微信openid")
-        private String openid;
-
-        @Schema(description = "微信unionid")
-        private String unionid;
-
-        @Schema(description = "微信昵称")
-        private String nickname;
-
-        @Schema(description = "微信头像")
-        private String avatar;
-    }
-
-}

src/main/java/com/gxwebsoft/auto/dto/QrLoginData.java

@@ -1,55 +0,0 @@
-package com.gxwebsoft.auto.dto;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.time.LocalDateTime;
-
-/**
- * 扫码登录数据模型
- *
- * @author 科技小王子
- * @since 2025-08-31
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-public class QrLoginData {
-
-    /**
-     * 扫码登录token
-     */
-    private String token;
-
-    /**
-     * 状态: pending-等待扫码, scanned-已扫码, confirmed-已确认, expired-已过期
-     */
-    private String status;
-
-    /**
-     * 用户ID(扫码确认后设置)
-     */
-    private Integer userId;
-
-    /**
-     * 用户名(扫码确认后设置)
-     */
-    private String username;
-
-    /**
-     * 创建时间
-     */
-    private LocalDateTime createTime;
-
-    /**
-     * 过期时间
-     */
-    private LocalDateTime expireTime;
-
-    /**
-     * JWT访问令牌(确认后生成)
-     */
-    private String accessToken;
-
-}

src/main/java/com/gxwebsoft/auto/dto/QrLoginGenerateResponse.java

@@ -1,29 +0,0 @@
-package com.gxwebsoft.auto.dto;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 扫码登录生成响应
- *
- * @author 科技小王子
- * @since 2025-08-31
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Schema(description = "扫码登录生成响应")
-public class QrLoginGenerateResponse {
-
-    @Schema(description = "扫码登录token")
-    private String token;
-
-    @Schema(description = "二维码内容")
-    private String qrCode;
-
-    @Schema(description = "过期时间(秒)")
-    private Long expiresIn;
-
-}

src/main/java/com/gxwebsoft/auto/dto/QrLoginStatusResponse.java

@@ -1,32 +0,0 @@
-package com.gxwebsoft.auto.dto;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * 扫码登录状态响应
- *
- * @author 科技小王子
- * @since 2025-08-31
- */
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Schema(description = "扫码登录状态响应")
-public class QrLoginStatusResponse {
-
-    @Schema(description = "状态: pending-等待扫码, scanned-已扫码, confirmed-已确认, expired-已过期")
-    private String status;
-
-    @Schema(description = "JWT访问令牌(仅在confirmed状态时返回)")
-    private String accessToken;
-
-    @Schema(description = "用户信息(仅在confirmed状态时返回)")
-    private Object userInfo;
-
-    @Schema(description = "剩余过期时间(秒)")
-    private Long expiresIn;
-
-}

src/main/java/com/gxwebsoft/auto/service/QrLoginService.java

@@ -1,46 +0,0 @@
-package com.gxwebsoft.auto.service;
-
-import com.gxwebsoft.auto.dto.QrLoginConfirmRequest;
-import com.gxwebsoft.auto.dto.QrLoginGenerateResponse;
-import com.gxwebsoft.auto.dto.QrLoginStatusResponse;
-
-/**
- * 扫码登录服务接口
- *
- * @author 科技小王子
- * @since 2025-08-31
- */
-public interface QrLoginService {
-
-    /**
-     * 生成扫码登录token
-     *
-     * @return QrLoginGenerateResponse
-     */
-    QrLoginGenerateResponse generateQrLoginToken();
-
-    /**
-     * 检查扫码登录状态
-     *
-     * @param token 扫码登录token
-     * @return QrLoginStatusResponse
-     */
-    QrLoginStatusResponse checkQrLoginStatus(String token);
-
-    /**
-     * 确认扫码登录
-     *
-     * @param request 确认请求
-     * @return QrLoginStatusResponse
-     */
-    QrLoginStatusResponse confirmQrLogin(QrLoginConfirmRequest request);
-
-    /**
-     * 扫码操作(更新状态为已扫码)
-     *
-     * @param token 扫码登录token
-     * @return boolean
-     */
-    boolean scanQrCode(String token);
-
-}

src/main/java/com/gxwebsoft/auto/service/impl/QrLoginServiceImpl.java

@@ -1,239 +0,0 @@
-package com.gxwebsoft.auto.service.impl;
-
-import cn.hutool.core.lang.UUID;
-import cn.hutool.core.util.StrUtil;
-import com.gxwebsoft.auto.dto.*;
-import com.gxwebsoft.auto.service.QrLoginService;
-import com.gxwebsoft.common.core.security.JwtSubject;
-import com.gxwebsoft.common.core.security.JwtUtil;
-import com.gxwebsoft.common.core.utils.JSONUtil;
-import com.gxwebsoft.common.core.utils.RedisUtil;
-import com.gxwebsoft.common.system.entity.User;
-import com.gxwebsoft.common.system.service.UserService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Service;
-
-import java.time.LocalDateTime;
-import java.time.temporal.ChronoUnit;
-import java.util.concurrent.TimeUnit;
-
-import static com.gxwebsoft.common.core.constants.RedisConstants.*;
-
-/**
- * 扫码登录服务实现
- *
- * @author 科技小王子
- * @since 2025-08-31
- */
-@Slf4j
-@Service
-public class QrLoginServiceImpl implements QrLoginService {
-
-    @Autowired
-    private RedisUtil redisUtil;
-
-    @Autowired
-    private UserService userService;
-
-    @Value("${config.jwt.secret:websoft-jwt-secret-key-2025}")
-    private String jwtSecret;
-
-    @Value("${config.jwt.expire:86400}")
-    private Long jwtExpire;
-
-    @Override
-    public QrLoginGenerateResponse generateQrLoginToken() {
-        // 生成唯一的扫码登录token
-        String token = UUID.randomUUID().toString(true);
-
-        // 创建扫码登录数据
-        QrLoginData qrLoginData = new QrLoginData();
-        qrLoginData.setToken(token);
-        qrLoginData.setStatus(QR_LOGIN_STATUS_PENDING);
-        qrLoginData.setCreateTime(LocalDateTime.now());
-        qrLoginData.setExpireTime(LocalDateTime.now().plusSeconds(QR_LOGIN_TOKEN_TTL));
-
-        // 存储到Redis，设置过期时间
-        String redisKey = QR_LOGIN_TOKEN_KEY + token;
-        redisUtil.set(redisKey, qrLoginData, QR_LOGIN_TOKEN_TTL, TimeUnit.SECONDS);
-
-        log.info("生成扫码登录token: {}", token);
-
-        // 构造二维码内容(这里可以是前端登录页面的URL + token参数)
-        String qrCodeContent = "qr-login:" + token;
-
-        return new QrLoginGenerateResponse(token, qrCodeContent, QR_LOGIN_TOKEN_TTL);
-    }
-
-    @Override
-    public QrLoginStatusResponse checkQrLoginStatus(String token) {
-        if (StrUtil.isBlank(token)) {
-            return new QrLoginStatusResponse(QR_LOGIN_STATUS_EXPIRED, null, null, 0L);
-        }
-
-        String redisKey = QR_LOGIN_TOKEN_KEY + token;
-        QrLoginData qrLoginData = redisUtil.get(redisKey, QrLoginData.class);
-
-        if (qrLoginData == null) {
-            return new QrLoginStatusResponse(QR_LOGIN_STATUS_EXPIRED, null, null, 0L);
-        }
-
-        // 检查是否过期
-        if (LocalDateTime.now().isAfter(qrLoginData.getExpireTime())) {
-            // 删除过期的token
-            redisUtil.delete(redisKey);
-            return new QrLoginStatusResponse(QR_LOGIN_STATUS_EXPIRED, null, null, 0L);
-        }
-
-        // 计算剩余过期时间
-        long expiresIn = ChronoUnit.SECONDS.between(LocalDateTime.now(), qrLoginData.getExpireTime());
-
-        QrLoginStatusResponse response = new QrLoginStatusResponse();
-        response.setStatus(qrLoginData.getStatus());
-        response.setExpiresIn(expiresIn);
-
-        // 如果已确认，返回token和用户信息
-        if (QR_LOGIN_STATUS_CONFIRMED.equals(qrLoginData.getStatus())) {
-            response.setAccessToken(qrLoginData.getAccessToken());
-
-            // 获取用户信息
-            if (qrLoginData.getUserId() != null) {
-                User user = userService.getByIdRel(qrLoginData.getUserId());
-                if (user != null) {
-                    // 清除敏感信息
-                    user.setPassword(null);
-                    response.setUserInfo(user);
-                }
-            }
-
-            // 确认后删除token，防止重复使用
-            redisUtil.delete(redisKey);
-        }
-
-        return response;
-    }
-
-    @Override
-    public QrLoginStatusResponse confirmQrLogin(QrLoginConfirmRequest request) {
-        String token = request.getToken();
-        Integer userId = request.getUserId();
-        String platform = request.getPlatform();
-
-        if (StrUtil.isBlank(token) || userId == null) {
-            throw new RuntimeException("参数不能为空");
-        }
-
-        String redisKey = QR_LOGIN_TOKEN_KEY + token;
-        QrLoginData qrLoginData = redisUtil.get(redisKey, QrLoginData.class);
-
-        if (qrLoginData == null) {
-            throw new RuntimeException("扫码登录token不存在或已过期");
-        }
-
-        // 检查是否过期
-        if (LocalDateTime.now().isAfter(qrLoginData.getExpireTime())) {
-            redisUtil.delete(redisKey);
-            throw new RuntimeException("扫码登录token已过期");
-        }
-
-        // 获取用户信息
-        User user = userService.getByIdRel(userId);
-        if (user == null) {
-            throw new RuntimeException("用户不存在");
-        }
-
-        // 检查用户状态
-        if (user.getStatus() != null && user.getStatus() != 0) {
-            throw new RuntimeException("用户已被冻结");
-        }
-
-        // 如果是微信小程序登录，处理微信相关信息
-        if ("miniprogram".equals(platform) && request.getWechatInfo() != null) {
-            handleWechatMiniProgramLogin(user, request.getWechatInfo());
-        }
-
-        // 生成JWT token
-        JwtSubject jwtSubject = new JwtSubject(user.getUsername(), user.getTenantId());
-        String accessToken = JwtUtil.buildToken(jwtSubject, jwtExpire, jwtSecret);
-
-        // 更新扫码登录数据
-        qrLoginData.setStatus(QR_LOGIN_STATUS_CONFIRMED);
-        qrLoginData.setUserId(userId);
-        qrLoginData.setUsername(user.getUsername());
-        qrLoginData.setAccessToken(accessToken);
-
-        // 更新Redis中的数据
-        redisUtil.set(redisKey, qrLoginData, 60L, TimeUnit.SECONDS); // 给前端60秒时间获取token
-
-        log.info("用户 {} 通过 {} 平台确认扫码登录，token: {}", user.getUsername(),
-                platform != null ? platform : "unknown", token);
-
-        // 清除敏感信息
-        user.setPassword(null);
-
-        return new QrLoginStatusResponse(QR_LOGIN_STATUS_CONFIRMED, accessToken, user, 60L);
-    }
-
-    /**
-     * 处理微信小程序登录相关逻辑
-     */
-    private void handleWechatMiniProgramLogin(User user, QrLoginConfirmRequest.WechatMiniProgramInfo wechatInfo) {
-        // 更新用户的微信信息
-        if (StrUtil.isNotBlank(wechatInfo.getOpenid())) {
-            user.setOpenid(wechatInfo.getOpenid());
-        }
-        if (StrUtil.isNotBlank(wechatInfo.getUnionid())) {
-            user.setUnionid(wechatInfo.getUnionid());
-        }
-        if (StrUtil.isNotBlank(wechatInfo.getNickname()) && StrUtil.isBlank(user.getNickname())) {
-            user.setNickname(wechatInfo.getNickname());
-        }
-        if (StrUtil.isNotBlank(wechatInfo.getAvatar()) && StrUtil.isBlank(user.getAvatar())) {
-            user.setAvatar(wechatInfo.getAvatar());
-        }
-
-        // 更新用户信息到数据库
-        try {
-            userService.updateById(user);
-            log.info("更新用户 {} 的微信小程序信息成功", user.getUsername());
-        } catch (Exception e) {
-            log.warn("更新用户 {} 的微信小程序信息失败: {}", user.getUsername(), e.getMessage());
-        }
-    }
-
-    @Override
-    public boolean scanQrCode(String token) {
-        if (StrUtil.isBlank(token)) {
-            return false;
-        }
-
-        String redisKey = QR_LOGIN_TOKEN_KEY + token;
-        QrLoginData qrLoginData = redisUtil.get(redisKey, QrLoginData.class);
-
-        if (qrLoginData == null) {
-            return false;
-        }
-
-        // 检查是否过期
-        if (LocalDateTime.now().isAfter(qrLoginData.getExpireTime())) {
-            redisUtil.delete(redisKey);
-            return false;
-        }
-
-        // 只有pending状态才能更新为scanned
-        if (QR_LOGIN_STATUS_PENDING.equals(qrLoginData.getStatus())) {
-            qrLoginData.setStatus(QR_LOGIN_STATUS_SCANNED);
-
-            // 计算剩余过期时间
-            long remainingSeconds = ChronoUnit.SECONDS.between(LocalDateTime.now(), qrLoginData.getExpireTime());
-            redisUtil.set(redisKey, qrLoginData, remainingSeconds, TimeUnit.SECONDS);
-
-            log.info("扫码登录token {} 状态更新为已扫码", token);
-            return true;
-        }
-
-        return false;
-    }
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicAppointmentController.java

@@ -1,122 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.clinic.service.ClinicAppointmentService;
-import com.gxwebsoft.clinic.entity.ClinicAppointment;
-import com.gxwebsoft.clinic.param.ClinicAppointmentParam;
-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 2025-10-19 09:27:04
- */
-@Tag(name = "挂号管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-appointment")
-public class ClinicAppointmentController extends BaseController {
-    @Resource
-    private ClinicAppointmentService clinicAppointmentService;
-
-    @Operation(summary = "分页查询挂号")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicAppointment>> page(ClinicAppointmentParam param) {
-        // 使用关联查询
-        return success(clinicAppointmentService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:list')")
-    @Operation(summary = "查询全部挂号")
-    @GetMapping()
-    public ApiResult<List<ClinicAppointment>> list(ClinicAppointmentParam param) {
-        // 使用关联查询
-        return success(clinicAppointmentService.listRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:list')")
-    @Operation(summary = "根据id查询挂号")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicAppointment> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicAppointmentService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:save')")
-    @OperationLog
-    @Operation(summary = "添加挂号")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicAppointment clinicAppointment) {
-        if (clinicAppointmentService.save(clinicAppointment)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:update')")
-    @OperationLog
-    @Operation(summary = "修改挂号")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicAppointment clinicAppointment) {
-        if (clinicAppointmentService.updateById(clinicAppointment)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:remove')")
-    @OperationLog
-    @Operation(summary = "删除挂号")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicAppointmentService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:save')")
-    @OperationLog
-    @Operation(summary = "批量添加挂号")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicAppointment> list) {
-        if (clinicAppointmentService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:update')")
-    @OperationLog
-    @Operation(summary = "批量修改挂号")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicAppointment> batchParam) {
-        if (batchParam.update(clinicAppointmentService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicAppointment:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除挂号")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicAppointmentService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicDoctorApplyController.java

@@ -1,128 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.clinic.service.ClinicDoctorApplyService;
-import com.gxwebsoft.clinic.entity.ClinicDoctorApply;
-import com.gxwebsoft.clinic.param.ClinicDoctorApplyParam;
-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 2025-10-19 09:27:04
- */
-@Tag(name = "医生入驻申请管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-doctor-apply")
-public class ClinicDoctorApplyController extends BaseController {
-    @Resource
-    private ClinicDoctorApplyService clinicDoctorApplyService;
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:list')")
-    @Operation(summary = "分页查询医生入驻申请")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicDoctorApply>> page(ClinicDoctorApplyParam param) {
-        // 使用关联查询
-        return success(clinicDoctorApplyService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:list')")
-    @Operation(summary = "查询全部医生入驻申请")
-    @GetMapping()
-    public ApiResult<List<ClinicDoctorApply>> list(ClinicDoctorApplyParam param) {
-        // 使用关联查询
-        return success(clinicDoctorApplyService.listRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:list')")
-    @Operation(summary = "根据id查询医生入驻申请")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicDoctorApply> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicDoctorApplyService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:save')")
-    @OperationLog
-    @Operation(summary = "添加医生入驻申请")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicDoctorApply clinicDoctorApply) {
-        // 记录当前登录用户id
-        // User loginUser = getLoginUser();
-        // if (loginUser != null) {
-        // clinicDoctorApply.setUserId(loginUser.getUserId());
-        // }
-        if (clinicDoctorApplyService.save(clinicDoctorApply)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:update')")
-    @OperationLog
-    @Operation(summary = "修改医生入驻申请")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicDoctorApply clinicDoctorApply) {
-        if (clinicDoctorApplyService.updateById(clinicDoctorApply)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:remove')")
-    @OperationLog
-    @Operation(summary = "删除医生入驻申请")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicDoctorApplyService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:save')")
-    @OperationLog
-    @Operation(summary = "批量添加医生入驻申请")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicDoctorApply> list) {
-        if (clinicDoctorApplyService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:update')")
-    @OperationLog
-    @Operation(summary = "批量修改医生入驻申请")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicDoctorApply> batchParam) {
-        if (batchParam.update(clinicDoctorApplyService, "apply_id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorApply:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除医生入驻申请")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicDoctorApplyService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicDoctorUserController.java

@@ -1,128 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.clinic.entity.ClinicDoctorUser;
-import com.gxwebsoft.clinic.param.ClinicDoctorUserParam;
-import com.gxwebsoft.clinic.service.ClinicDoctorUserService;
-import com.gxwebsoft.common.core.annotation.OperationLog;
-import com.gxwebsoft.common.core.web.ApiResult;
-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 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 2025-10-23 15:58:21
- */
-@Tag(name = "分销商用户记录表管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-doctor-user")
-public class ClinicDoctorUserController extends BaseController {
-    @Resource
-    private ClinicDoctorUserService clinicDoctorUserService;
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:list')")
-    @Operation(summary = "分页查询分销商用户记录表")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicDoctorUser>> page(ClinicDoctorUserParam param) {
-        // 使用关联查询
-        return success(clinicDoctorUserService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:list')")
-    @Operation(summary = "查询全部分销商用户记录表")
-    @GetMapping()
-    public ApiResult<List<ClinicDoctorUser>> list(ClinicDoctorUserParam param) {
-        // 使用关联查询
-        return success(clinicDoctorUserService.listRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:list')")
-    @Operation(summary = "根据id查询分销商用户记录表")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicDoctorUser> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicDoctorUserService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:save')")
-    @OperationLog
-    @Operation(summary = "添加分销商用户记录表")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicDoctorUser clinicDoctorUser) {
-        // 记录当前登录用户id
-         User loginUser = getLoginUser();
-         if (loginUser != null) {
-         clinicDoctorUser.setUserId(loginUser.getUserId());
-         }
-        if (clinicDoctorUserService.save(clinicDoctorUser)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:update')")
-    @OperationLog
-    @Operation(summary = "修改分销商用户记录表")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicDoctorUser clinicDoctorUser) {
-        if (clinicDoctorUserService.updateById(clinicDoctorUser)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:remove')")
-    @OperationLog
-    @Operation(summary = "删除分销商用户记录表")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicDoctorUserService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:save')")
-    @OperationLog
-    @Operation(summary = "批量添加分销商用户记录表")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicDoctorUser> list) {
-        if (clinicDoctorUserService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:update')")
-    @OperationLog
-    @Operation(summary = "批量修改分销商用户记录表")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicDoctorUser> batchParam) {
-        if (batchParam.update(clinicDoctorUserService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicDoctorUser:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除分销商用户记录表")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicDoctorUserService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicMedicineController.java

@@ -1,127 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.clinic.entity.ClinicMedicine;
-import com.gxwebsoft.clinic.param.ClinicMedicineParam;
-import com.gxwebsoft.clinic.service.ClinicMedicineService;
-import com.gxwebsoft.common.core.annotation.OperationLog;
-import com.gxwebsoft.common.core.web.ApiResult;
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.common.core.web.BatchParam;
-import com.gxwebsoft.common.core.web.PageResult;
-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 2025-10-22 02:06:32
- */
-@Tag(name = "药品库管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-medicine")
-public class ClinicMedicineController extends BaseController {
-    @Resource
-    private ClinicMedicineService clinicMedicineService;
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:list')")
-    @Operation(summary = "分页查询药品库")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicMedicine>> page(ClinicMedicineParam param) {
-        // 使用关联查询
-        return success(clinicMedicineService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:list')")
-    @Operation(summary = "查询全部药品库")
-    @GetMapping()
-    public ApiResult<List<ClinicMedicine>> list(ClinicMedicineParam param) {
-        // 使用关联查询
-        return success(clinicMedicineService.listRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:list')")
-    @Operation(summary = "根据id查询药品库")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicMedicine> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicMedicineService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:save')")
-    @OperationLog
-    @Operation(summary = "添加药品库")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicMedicine clinicMedicine) {
-        // 记录当前登录用户id
-        // User loginUser = getLoginUser();
-        // if (loginUser != null) {
-        // clinicMedicine.setUserId(loginUser.getUserId());
-        // }
-        if (clinicMedicineService.save(clinicMedicine)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:update')")
-    @OperationLog
-    @Operation(summary = "修改药品库")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicMedicine clinicMedicine) {
-        if (clinicMedicineService.updateById(clinicMedicine)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:remove')")
-    @OperationLog
-    @Operation(summary = "删除药品库")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicMedicineService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:save')")
-    @OperationLog
-    @Operation(summary = "批量添加药品库")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicMedicine> list) {
-        if (clinicMedicineService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:update')")
-    @OperationLog
-    @Operation(summary = "批量修改药品库")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicMedicine> batchParam) {
-        if (batchParam.update(clinicMedicineService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicine:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除药品库")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicMedicineService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicMedicineInoutController.java

@@ -1,127 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.clinic.entity.ClinicMedicineInout;
-import com.gxwebsoft.clinic.param.ClinicMedicineInoutParam;
-import com.gxwebsoft.clinic.service.ClinicMedicineInoutService;
-import com.gxwebsoft.common.core.annotation.OperationLog;
-import com.gxwebsoft.common.core.web.ApiResult;
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.common.core.web.BatchParam;
-import com.gxwebsoft.common.core.web.PageResult;
-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 2025-10-22 02:06:32
- */
-@Tag(name = "出入库管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-medicine-inout")
-public class ClinicMedicineInoutController extends BaseController {
-    @Resource
-    private ClinicMedicineInoutService clinicMedicineInoutService;
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:list')")
-    @Operation(summary = "分页查询出入库")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicMedicineInout>> page(ClinicMedicineInoutParam param) {
-        // 使用关联查询
-        return success(clinicMedicineInoutService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:list')")
-    @Operation(summary = "查询全部出入库")
-    @GetMapping()
-    public ApiResult<List<ClinicMedicineInout>> list(ClinicMedicineInoutParam param) {
-        // 使用关联查询
-        return success(clinicMedicineInoutService.listRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:list')")
-    @Operation(summary = "根据id查询出入库")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicMedicineInout> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicMedicineInoutService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:save')")
-    @OperationLog
-    @Operation(summary = "添加出入库")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicMedicineInout clinicMedicineInout) {
-        // 记录当前登录用户id
-        // User loginUser = getLoginUser();
-        // if (loginUser != null) {
-        // clinicMedicineInout.setUserId(loginUser.getUserId());
-        // }
-        if (clinicMedicineInoutService.save(clinicMedicineInout)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:update')")
-    @OperationLog
-    @Operation(summary = "修改出入库")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicMedicineInout clinicMedicineInout) {
-        if (clinicMedicineInoutService.updateById(clinicMedicineInout)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:remove')")
-    @OperationLog
-    @Operation(summary = "删除出入库")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicMedicineInoutService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:save')")
-    @OperationLog
-    @Operation(summary = "批量添加出入库")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicMedicineInout> list) {
-        if (clinicMedicineInoutService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:update')")
-    @OperationLog
-    @Operation(summary = "批量修改出入库")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicMedicineInout> batchParam) {
-        if (batchParam.update(clinicMedicineInoutService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineInout:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除出入库")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicMedicineInoutService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicMedicineStockController.java

@@ -1,127 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.clinic.entity.ClinicMedicineStock;
-import com.gxwebsoft.clinic.param.ClinicMedicineStockParam;
-import com.gxwebsoft.clinic.service.ClinicMedicineStockService;
-import com.gxwebsoft.common.core.annotation.OperationLog;
-import com.gxwebsoft.common.core.web.ApiResult;
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.common.core.web.BatchParam;
-import com.gxwebsoft.common.core.web.PageResult;
-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 2025-10-22 02:06:32
- */
-@Tag(name = "药品库存管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-medicine-stock")
-public class ClinicMedicineStockController extends BaseController {
-    @Resource
-    private ClinicMedicineStockService clinicMedicineStockService;
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:list')")
-    @Operation(summary = "分页查询药品库存")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicMedicineStock>> page(ClinicMedicineStockParam param) {
-        // 使用关联查询
-        return success(clinicMedicineStockService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:list')")
-    @Operation(summary = "查询全部药品库存")
-    @GetMapping()
-    public ApiResult<List<ClinicMedicineStock>> list(ClinicMedicineStockParam param) {
-        // 使用关联查询
-        return success(clinicMedicineStockService.listRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:list')")
-    @Operation(summary = "根据id查询药品库存")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicMedicineStock> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicMedicineStockService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:save')")
-    @OperationLog
-    @Operation(summary = "添加药品库存")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicMedicineStock clinicMedicineStock) {
-        // 记录当前登录用户id
-        // User loginUser = getLoginUser();
-        // if (loginUser != null) {
-        // clinicMedicineStock.setUserId(loginUser.getUserId());
-        // }
-        if (clinicMedicineStockService.save(clinicMedicineStock)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:update')")
-    @OperationLog
-    @Operation(summary = "修改药品库存")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicMedicineStock clinicMedicineStock) {
-        if (clinicMedicineStockService.updateById(clinicMedicineStock)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:remove')")
-    @OperationLog
-    @Operation(summary = "删除药品库存")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicMedicineStockService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:save')")
-    @OperationLog
-    @Operation(summary = "批量添加药品库存")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicMedicineStock> list) {
-        if (clinicMedicineStockService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:update')")
-    @OperationLog
-    @Operation(summary = "批量修改药品库存")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicMedicineStock> batchParam) {
-        if (batchParam.update(clinicMedicineStockService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicMedicineStock:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除药品库存")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicMedicineStockService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicPatientUserController.java

@@ -1,129 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.clinic.service.ClinicPatientUserService;
-import com.gxwebsoft.clinic.entity.ClinicPatientUser;
-import com.gxwebsoft.clinic.param.ClinicPatientUserParam;
-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 com.gxwebsoft.common.system.entity.User;
-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 2025-10-19 09:27:04
- */
-@Tag(name = "患者管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-patient-user")
-public class ClinicPatientUserController extends BaseController {
-    @Resource
-    private ClinicPatientUserService clinicPatientUserService;
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:list')")
-    @Operation(summary = "分页查询患者")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicPatientUser>> page(ClinicPatientUserParam param) {
-        // 使用关联查询
-        return success(clinicPatientUserService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:list')")
-    @Operation(summary = "查询全部患者")
-    @GetMapping()
-    public ApiResult<List<ClinicPatientUser>> list(ClinicPatientUserParam param) {
-        // 使用关联查询
-        return success(clinicPatientUserService.listRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:list')")
-    @Operation(summary = "根据id查询患者")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicPatientUser> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicPatientUserService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:save')")
-    @OperationLog
-    @Operation(summary = "添加患者")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicPatientUser clinicPatientUser) {
-        // 记录当前登录用户id
-         User loginUser = getLoginUser();
-         if (loginUser != null) {
-         clinicPatientUser.setUserId(loginUser.getUserId());
-         }
-        if (clinicPatientUserService.save(clinicPatientUser)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:update')")
-    @OperationLog
-    @Operation(summary = "修改患者")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicPatientUser clinicPatientUser) {
-        if (clinicPatientUserService.updateById(clinicPatientUser)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:remove')")
-    @OperationLog
-    @Operation(summary = "删除患者")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicPatientUserService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:save')")
-    @OperationLog
-    @Operation(summary = "批量添加患者")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicPatientUser> list) {
-        if (clinicPatientUserService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:update')")
-    @OperationLog
-    @Operation(summary = "批量修改患者")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicPatientUser> batchParam) {
-        if (batchParam.update(clinicPatientUserService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPatientUser:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除患者")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicPatientUserService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicPrescriptionController.java

@@ -1,191 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import cn.hutool.core.util.IdUtil;
-import com.gxwebsoft.clinic.dto.PrescriptionOrderRequest;
-import com.gxwebsoft.clinic.entity.ClinicPrescription;
-import com.gxwebsoft.clinic.param.ClinicPrescriptionParam;
-import com.gxwebsoft.clinic.service.ClinicPrescriptionService;
-import com.gxwebsoft.common.core.annotation.OperationLog;
-import com.gxwebsoft.common.core.web.ApiResult;
-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 io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.security.access.prepost.PreAuthorize;
-import org.springframework.web.bind.annotation.*;
-
-import javax.annotation.Resource;
-import java.time.LocalDateTime;
-import java.util.List;
-
-/**
- * 处方主表
-控制器
- *
- * @author 科技小王子
- * @since 2025-10-22 02:01:13
- */
-@Tag(name = "处方主表管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-prescription")
-public class ClinicPrescriptionController extends BaseController {
-    @Resource
-    private ClinicPrescriptionService clinicPrescriptionService;
-
-    @Operation(summary = "分页查询处方主表")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicPrescription>> page(ClinicPrescriptionParam param) {
-        // 使用关联查询
-        return success(clinicPrescriptionService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:list')")
-    @Operation(summary = "查询全部处方主表")
-    @GetMapping()
-    public ApiResult<List<ClinicPrescription>> list(ClinicPrescriptionParam param) {
-        // 使用关联查询
-        return success(clinicPrescriptionService.listRel(param));
-    }
-
-    @Operation(summary = "根据id查询处方主表")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicPrescription> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicPrescriptionService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:save')")
-    @OperationLog
-    @Operation(summary = "添加处方主表")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicPrescription clinicPrescription) {
-        // 记录当前登录用户id
-         User loginUser = getLoginUser();
-         if (loginUser != null) {
-          clinicPrescription.setDoctorId(loginUser.getUserId());
-           // 生成订单号
-           String orderNo = Long.toString(IdUtil.getSnowflakeNextId());
-           clinicPrescription.setOrderNo(orderNo);
-         }
-        if (clinicPrescriptionService.save(clinicPrescription)) {
-            // 返回处方数据，包含处方ID
-            return success("添加成功",clinicPrescriptionService.getByLastId(clinicPrescription));
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:update')")
-    @OperationLog
-    @Operation(summary = "修改处方主表")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicPrescription clinicPrescription) {
-        if (clinicPrescriptionService.updateById(clinicPrescription)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:remove')")
-    @OperationLog
-    @Operation(summary = "删除处方主表")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicPrescriptionService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:save')")
-    @OperationLog
-    @Operation(summary = "批量添加处方主表")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicPrescription> list) {
-        if (clinicPrescriptionService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:update')")
-    @OperationLog
-    @Operation(summary = "批量修改处方主表")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicPrescription> batchParam) {
-        if (batchParam.update(clinicPrescriptionService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除处方主表")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicPrescriptionService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @Operation(summary = "创建处方订单")
-    @PostMapping("/order")
-    public ApiResult<?> createOrder(@RequestBody PrescriptionOrderRequest request) {
-        try {
-            // 1. 参数校验
-            if (request.getPrescriptionId() == null) {
-                return fail("处方ID不能为空");
-            }
-            if (request.getPayType() == null) {
-                return fail("支付方式不能为空");
-            }
-
-            // 2. 查询处方信息
-            ClinicPrescription prescription = clinicPrescriptionService.getById(request.getPrescriptionId());
-            if (prescription == null) {
-                return fail("处方不存在");
-            }
-
-            // 3. 检查处方状态
-            if (prescription.getStatus() != null && prescription.getStatus() == 2) {
-                return fail("该处方已支付，无需重复支付");
-            }
-            if (prescription.getStatus() != null && prescription.getStatus() == 3) {
-                return fail("该处方已取消，无法支付");
-            }
-
-            // 4. 更新处方订单信息
-            ClinicPrescription updatePrescription = new ClinicPrescription();
-            updatePrescription.setId(request.getPrescriptionId());
-            
-            // 根据支付类型更新状态
-            if (request.getPayType() == 1) {
-                // 微信支付，状态保持为正常，等待支付回调
-                updatePrescription.setStatus(0);
-            } else if (request.getPayType() == 4 || request.getPayType() == 5) {
-                // 现金支付或POS机支付，直接标记为已支付
-                updatePrescription.setStatus(2);
-                updatePrescription.setIsSettled(1);
-                updatePrescription.setSettleTime(LocalDateTime.now());
-            } else if (request.getPayType() == 6) {
-                // 免费，直接标记为已完成
-                updatePrescription.setStatus(1);
-                updatePrescription.setIsSettled(1);
-                updatePrescription.setSettleTime(LocalDateTime.now());
-            }
-
-            if (clinicPrescriptionService.updateById(updatePrescription)) {
-                return success("订单创建成功", prescription);
-            }
-            return fail("订单创建失败");
-
-        } catch (Exception e) {
-            return fail("订单创建失败：" + e.getMessage());
-        }
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/controller/ClinicPrescriptionItemController.java

@@ -1,121 +0,0 @@
-package com.gxwebsoft.clinic.controller;
-
-import com.gxwebsoft.clinic.entity.ClinicPrescriptionItem;
-import com.gxwebsoft.clinic.param.ClinicPrescriptionItemParam;
-import com.gxwebsoft.clinic.service.ClinicPrescriptionItemService;
-import com.gxwebsoft.common.core.annotation.OperationLog;
-import com.gxwebsoft.common.core.web.ApiResult;
-import com.gxwebsoft.common.core.web.BaseController;
-import com.gxwebsoft.common.core.web.BatchParam;
-import com.gxwebsoft.common.core.web.PageResult;
-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 2025-10-22 02:01:13
- */
-@Tag(name = "处方明细表管理")
-@RestController
-@RequestMapping("/api/clinic/clinic-prescription-item")
-public class ClinicPrescriptionItemController extends BaseController {
-    @Resource
-    private ClinicPrescriptionItemService clinicPrescriptionItemService;
-
-    @Operation(summary = "分页查询处方明细表")
-    @GetMapping("/page")
-    public ApiResult<PageResult<ClinicPrescriptionItem>> page(ClinicPrescriptionItemParam param) {
-        // 使用关联查询
-        return success(clinicPrescriptionItemService.pageRel(param));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:list')")
-    @Operation(summary = "查询全部处方明细表")
-    @GetMapping()
-    public ApiResult<List<ClinicPrescriptionItem>> list(ClinicPrescriptionItemParam param) {
-        // 使用关联查询
-        return success(clinicPrescriptionItemService.listRel(param));
-    }
-
-    @Operation(summary = "根据id查询处方明细表")
-    @GetMapping("/{id}")
-    public ApiResult<ClinicPrescriptionItem> get(@PathVariable("id") Integer id) {
-        // 使用关联查询
-        return success(clinicPrescriptionItemService.getByIdRel(id));
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:save')")
-    @OperationLog
-    @Operation(summary = "添加处方明细表")
-    @PostMapping()
-    public ApiResult<?> save(@RequestBody ClinicPrescriptionItem clinicPrescriptionItem) {
-        if (clinicPrescriptionItemService.save(clinicPrescriptionItem)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:update')")
-    @OperationLog
-    @Operation(summary = "修改处方明细表")
-    @PutMapping()
-    public ApiResult<?> update(@RequestBody ClinicPrescriptionItem clinicPrescriptionItem) {
-        if (clinicPrescriptionItemService.updateById(clinicPrescriptionItem)) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:remove')")
-    @OperationLog
-    @Operation(summary = "删除处方明细表")
-    @DeleteMapping("/{id}")
-    public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (clinicPrescriptionItemService.removeById(id)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:save')")
-    @OperationLog
-    @Operation(summary = "批量添加处方明细表")
-    @PostMapping("/batch")
-    public ApiResult<?> saveBatch(@RequestBody List<ClinicPrescriptionItem> list) {
-        if (clinicPrescriptionItemService.saveBatch(list)) {
-            return success("添加成功");
-        }
-        return fail("添加失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:update')")
-    @OperationLog
-    @Operation(summary = "批量修改处方明细表")
-    @PutMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody BatchParam<ClinicPrescriptionItem> batchParam) {
-        if (batchParam.update(clinicPrescriptionItemService, "id")) {
-            return success("修改成功");
-        }
-        return fail("修改失败");
-    }
-
-    @PreAuthorize("hasAuthority('clinic:clinicPrescription:remove')")
-    @OperationLog
-    @Operation(summary = "批量删除处方明细表")
-    @DeleteMapping("/batch")
-    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (clinicPrescriptionItemService.removeByIds(ids)) {
-            return success("删除成功");
-        }
-        return fail("删除失败");
-    }
-
-}

src/main/java/com/gxwebsoft/clinic/dto/PrescriptionOrderRequest.java

@@ -1,24 +0,0 @@
-package com.gxwebsoft.clinic.dto;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-
-import java.io.Serializable;
-
-/**
- * 处方订单请求参数
- *
- * @author 科技小王子
- * @since 2025-11-03
- */
-@Data
-@Schema(name = "PrescriptionOrderRequest", description = "处方订单请求参数")
-public class PrescriptionOrderRequest implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-    @Schema(description = "处方ID", required = true)
-    private Integer prescriptionId;
-
-    @Schema(description = "支付方式：0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付", required = true)
-    private Integer payType;
-}

src/main/java/com/gxwebsoft/clinic/entity/ClinicDoctorApply.java

@@ -1,125 +0,0 @@
-package com.gxwebsoft.clinic.entity;
-
-import java.math.BigDecimal;
-import com.baomidou.mybatisplus.annotation.IdType;
-import java.time.LocalDate;
-import com.baomidou.mybatisplus.annotation.TableId;
-import java.time.LocalDateTime;
-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 2025-10-19 09:27:04
- */
-@Data
-@EqualsAndHashCode(callSuper = false)
-@Schema(name = "ClinicDoctorApply对象", description = "医生入驻申请")
-public class ClinicDoctorApply implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-    @Schema(description = "主键ID")
-    @TableId(value = "apply_id", type = IdType.AUTO)
-    private Integer applyId;
-
-    @Schema(description = "类型 0医生")
-    private Integer type;
-
-    @Schema(description = "用户ID")
-    private Integer userId;
-
-    @Schema(description = "姓名")
-    private String realName;
-
-    @Schema(description = "性别 1男 2女")
-    private Integer gender;
-
-    @Schema(description = "手机号")
-    private String mobile;
-
-    @Schema(description = "客户名称")
-    private String dealerName;
-
-    @Schema(description = "证件号码")
-    private String idCard;
-
-    @Schema(description = "生日")
-    @JsonFormat(pattern = "yyyy-MM-dd")
-    private LocalDate birthDate;
-
-    @Schema(description = "区分职称等级（如主治医师、副主任医师）")
-    private String professionalTitle;
-
-    @Schema(description = "工作单位")
-    private String workUnit;
-
-    @Schema(description = "执业资格核心凭证")
-    private String practiceLicense;
-
-    @Schema(description = "限定可执业科室或疾病类型")
-    private String practiceScope;
-
-    @Schema(description = "开始工作时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime startWorkDate;
-
-    @Schema(description = "简历")
-    private String resume;
-
-    @Schema(description = "使用 JSON 存储多个证件文件路径（如执业证、学历证）")
-    private String certificationFiles;
-
-    @Schema(description = "详细地址")
-    private String address;
-
-    @Schema(description = "签约价格")
-    private BigDecimal money;
-
-    @Schema(description = "推荐人用户ID")
-    private Integer refereeId;
-
-    @Schema(description = "申请方式(10需后台审核 20无需审核)")
-    private Integer applyType;
-
-    @Schema(description = "审核状态 (10待审核 20审核通过 30驳回)")
-    private Integer applyStatus;
-
-    @Schema(description = "申请时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime applyTime;
-
-    @Schema(description = "审核时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime auditTime;
-
-    @Schema(description = "合同时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime contractTime;
-
-    @Schema(description = "过期时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime expirationTime;
-
-    @Schema(description = "驳回原因")
-    private String rejectReason;
-
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "商城ID")
-    private Integer tenantId;
-
-    @Schema(description = "创建时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime createTime;
-
-    @Schema(description = "修改时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime updateTime;
-
-}

src/main/java/com/gxwebsoft/clinic/entity/ClinicDoctorUser.java

@@ -1,99 +0,0 @@
-package com.gxwebsoft.clinic.entity;
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 分销商用户记录表
- *
- * @author 科技小王子
- * @since 2025-10-23 15:58:20
- */
-@Data
-@EqualsAndHashCode(callSuper = false)
-@Schema(name = "ClinicDoctorUser对象", description = "分销商用户记录表")
-public class ClinicDoctorUser 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 = "自增ID")
-    private Integer userId;
-
-    @Schema(description = "昵称")
-    @TableField(exist = false)
-    private String nickname;
-
-    @Schema(description = "头像")
-    @TableField(exist = false)
-    private String avatar;
-
-    @Schema(description = "姓名")
-    private String realName;
-
-    @Schema(description = "手机号")
-    @TableField(exist = false)
-    private String phone;
-
-    @Schema(description = "部门")
-    private Integer departmentId;
-
-    @Schema(description = "专业领域")
-    private String specialty;
-
-    @Schema(description = "职务级别")
-    private String position;
-
-    @Schema(description = "执业资格")
-    private String qualification;
-
-    @Schema(description = "医生简介")
-    private String introduction;
-
-    @Schema(description = "挂号费")
-    private BigDecimal consultationFee;
-
-    @Schema(description = "工作年限")
-    private Integer workYears;
-
-    @Schema(description = "问诊人数")
-    private Integer consultationCount;
-
-    @Schema(description = "专属二维码")
-    private String qrcode;
-
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "排序号")
-    private Integer sortNumber;
-
-    @Schema(description = "是否删除")
-    private Integer isDelete;
-
-    @Schema(description = "租户id")
-    private Integer tenantId;
-
-    @Schema(description = "创建时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime createTime;
-
-    @Schema(description = "修改时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime updateTime;
-
-}

src/main/java/com/gxwebsoft/clinic/entity/ClinicMedicine.java

@@ -1,71 +0,0 @@
-package com.gxwebsoft.clinic.entity;
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 药品库
- *
- * @author 科技小王子
- * @since 2025-10-22 02:06:31
- */
-@Data
-@EqualsAndHashCode(callSuper = false)
-@Schema(name = "ClinicMedicine对象", description = "药品库")
-public class ClinicMedicine implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-    @Schema(description = "主键ID")
-    @TableId(value = "id", type = IdType.AUTO)
-    private Integer id;
-
-    @Schema(description = "药名")
-    private String name;
-
-    @Schema(description = "拼音")
-    private String pinyin;
-
-    @Schema(description = "分类（如“清热解毒”、“补气养血”）")
-    private String category;
-
-    @Schema(description = "规格（如“饮片”、“颗粒”）")
-    private String specification;
-
-    @Schema(description = "单位（如“克”、“袋”）")
-    private String unit;
-
-    @Schema(description = "描述")
-    private String content;
-
-    @Schema(description = "单价")
-    private BigDecimal pricePerUnit;
-
-    @Schema(description = "是否活跃")
-    private Integer isActive;
-
-    @Schema(description = "买家用户ID")
-    private Integer userId;
-
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "商城ID")
-    private Integer tenantId;
-
-    @Schema(description = "创建时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime createTime;
-
-    @Schema(description = "修改时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime updateTime;
-
-}

src/main/java/com/gxwebsoft/clinic/entity/ClinicMedicineInout.java

@@ -1,99 +0,0 @@
-package com.gxwebsoft.clinic.entity;
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 出入库
- *
- * @author 科技小王子
- * @since 2025-10-22 02:06:32
- */
-@Data
-@EqualsAndHashCode(callSuper = false)
-@Schema(name = "ClinicMedicineInout对象", description = "出入库")
-public class ClinicMedicineInout implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-    @Schema(description = "主键ID")
-    @TableId(value = "id", type = IdType.AUTO)
-    private Integer id;
-
-    @Schema(description = "买家用户ID")
-    private Integer userId;
-
-    @Schema(description = "订单编号")
-    private String orderNo;
-
-    @Schema(description = "分销商用户id(一级)")
-    private Integer firstUserId;
-
-    @Schema(description = "分销商用户id(二级)")
-    private Integer secondUserId;
-
-    @Schema(description = "分销商用户id(三级)")
-    private Integer thirdUserId;
-
-    @Schema(description = "分销佣金(一级)")
-    private BigDecimal firstMoney;
-
-    @Schema(description = "分销佣金(二级)")
-    private BigDecimal secondMoney;
-
-    @Schema(description = "分销佣金(三级)")
-    private BigDecimal thirdMoney;
-
-    @Schema(description = "单价")
-    private BigDecimal price;
-
-    @Schema(description = "订单总金额")
-    private BigDecimal orderPrice;
-
-    @Schema(description = "结算金额")
-    private BigDecimal settledPrice;
-
-    @Schema(description = "换算成度")
-    private BigDecimal degreePrice;
-
-    @Schema(description = "实发金额")
-    private BigDecimal payPrice;
-
-    @Schema(description = "税率")
-    private BigDecimal rate;
-
-    @Schema(description = "结算月份")
-    private String month;
-
-    @Schema(description = "订单是否失效(0未失效 1已失效)")
-    private Integer isInvalid;
-
-    @Schema(description = "佣金结算(0未结算 1已结算)")
-    private Integer isSettled;
-
-    @Schema(description = "结算时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime settleTime;
-
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "商城ID")
-    private Integer tenantId;
-
-    @Schema(description = "创建时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime createTime;
-
-    @Schema(description = "修改时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime updateTime;
-
-}

src/main/java/com/gxwebsoft/clinic/entity/ClinicPrescription.java

@@ -1,133 +0,0 @@
-package com.gxwebsoft.clinic.entity;
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import com.gxwebsoft.shop.entity.ShopOrder;
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-
-/**
- * 处方主表
-
- *
- * @author 科技小王子
- * @since 2025-10-22 02:01:13
- */
-@Data
-@EqualsAndHashCode(callSuper = false)
-@Schema(name = "ClinicPrescription对象", description = "处方主表")
-public class ClinicPrescription implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-    @Schema(description = "主键ID")
-    @TableId(value = "id", type = IdType.AUTO)
-    private Integer id;
-
-    @Schema(description = "患者")
-    private Integer userId;
-
-    @Schema(description = "患者名称")
-    @TableField(exist = false)
-    private String realName;
-
-    @Schema(description = "年龄")
-    @TableField(exist = false)
-    private String age;
-
-    @Schema(description = "身高")
-    @TableField(exist = false)
-    private String height;
-
-    @Schema(description = "体重")
-    @TableField(exist = false)
-    private String weight;
-
-    @Schema(description = "医生")
-    private Integer doctorId;
-
-    @Schema(description = "医生名称")
-    @TableField(exist = false)
-    private String doctorName;
-
-    @Schema(description = "医生资格")
-    @TableField(exist = false)
-    private String qualification;
-
-    @Schema(description = "订单编号")
-    private String orderNo;
-
-    @Schema(description = "0未付款，1已付款")
-    @TableField(exist = false)
-    private Boolean payStatus;
-
-    @Schema(description = "0未使用，1已完成，2已取消，3取消中，4退款申请中，5退款被拒绝，6退款成功，7客户端申请退款")
-    @TableField(exist = false)
-    private Integer orderStatus;
-
-    @Schema(description = "关联就诊表")
-    private Integer visitRecordId;
-
-    @Schema(description = "处方类型 0中药 1西药")
-    private Integer prescriptionType;
-
-    @Schema(description = "诊断结果")
-    private String diagnosis;
-
-    @Schema(description = "治疗方案")
-    private String treatmentPlan;
-
-    @Schema(description = "煎药说明")
-    private String decoctionInstructions;
-
-    @Schema(description = "上传附件")
-    private String image;
-
-    @Schema(description = "订单总金额")
-    private BigDecimal orderPrice;
-
-    @Schema(description = "单价")
-    private BigDecimal price;
-
-    @Schema(description = "实付金额")
-    private BigDecimal payPrice;
-
-    @Schema(description = "订单是否失效(0未失效 1已失效)")
-    private Integer isInvalid;
-
-    @Schema(description = "结算(0未结算 1已结算)")
-    private Integer isSettled;
-
-    @Schema(description = "结算时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime settleTime;
-
-    @Schema(description = "状态, 0正常, 1已完成，2已支付，3已取消")
-    private Integer status;
-
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "商城ID")
-    private Integer tenantId;
-
-    @Schema(description = "创建时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime createTime;
-
-    @Schema(description = "修改时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime updateTime;
-
-    @Schema(description = "处方明细")
-    @TableField(exist = false)
-    private List<ClinicPrescriptionItem> items;
-
-}

src/main/java/com/gxwebsoft/clinic/entity/ClinicPrescriptionItem.java

@@ -1,99 +0,0 @@
-package com.gxwebsoft.clinic.entity;
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-
-/**
- * 处方明细表
-
- *
- * @author 科技小王子
- * @since 2025-10-22 02:01:13
- */
-@Data
-@EqualsAndHashCode(callSuper = false)
-@Schema(name = "ClinicPrescriptionItem对象", description = "处方明细表")
-public class ClinicPrescriptionItem implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-    @Schema(description = "自增ID")
-    @TableId(value = "id", type = IdType.AUTO)
-    private Integer id;
-
-    @Schema(description = "关联处方")
-    private Integer prescriptionId;
-
-    @Schema(description = "订单编号")
-    private String prescriptionNo;
-
-    @Schema(description = "关联药品")
-    private Integer medicineId;
-
-    @Schema(description = "药品名称")
-    @TableField(exist = false)
-    private String medicineName;
-
-    @Schema(description = "规格")
-    @TableField(exist = false)
-    private String specification;
-
-    @Schema(description = "单位")
-    @TableField(exist = false)
-    private String unit;
-
-    @Schema(description = "单价")
-    @TableField(exist = false)
-    private BigDecimal pricePerUnit;
-
-    @Schema(description = "药品")
-    @TableField(exist = false)
-    private ClinicMedicine clinicMedicine;
-
-    @Schema(description = "剂量（如“10g”）")
-    private String dosage;
-
-    @Schema(description = "用法频率（如“每日三次”）")
-    private String usageFrequency;
-
-    @Schema(description = "服用天数")
-    private Integer days;
-
-    @Schema(description = "购买数量")
-    private Integer amount;
-
-    @Schema(description = "单价")
-    private BigDecimal unitPrice;
-
-    @Schema(description = "数量")
-    private Integer quantity;
-
-    @Schema(description = "排序号")
-    private Integer sortNumber;
-
-    @Schema(description = "备注")
-    private String comments;
-
-    @Schema(description = "用户id")
-    private Integer userId;
-
-    @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/clinic/mapper/ClinicAppointmentMapper.java

@@ -1,37 +0,0 @@
-package com.gxwebsoft.clinic.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.gxwebsoft.clinic.entity.ClinicAppointment;
-import com.gxwebsoft.clinic.param.ClinicAppointmentParam;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-/**
- * 挂号Mapper
- *
- * @author 科技小王子
- * @since 2025-10-19 09:27:03
- */
-public interface ClinicAppointmentMapper extends BaseMapper<ClinicAppointment> {
-
-    /**
-     * 分页查询
-     *
-     * @param page  分页对象
-     * @param param 查询参数
-     * @return List<ClinicAppointment>
-     */
-    List<ClinicAppointment> selectPageRel(@Param("page") IPage<ClinicAppointment> page,
-                             @Param("param") ClinicAppointmentParam param);
-
-    /**
-     * 查询全部
-     *
-     * @param param 查询参数
-     * @return List<User>
-     */
-    List<ClinicAppointment> selectListRel(@Param("param") ClinicAppointmentParam param);
-
-}

src/main/java/com/gxwebsoft/clinic/mapper/ClinicDoctorApplyMapper.java

@@ -1,37 +0,0 @@
-package com.gxwebsoft.clinic.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.gxwebsoft.clinic.entity.ClinicDoctorApply;
-import com.gxwebsoft.clinic.param.ClinicDoctorApplyParam;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-/**
- * 医生入驻申请Mapper
- *
- * @author 科技小王子
- * @since 2025-10-19 09:27:04
- */
-public interface ClinicDoctorApplyMapper extends BaseMapper<ClinicDoctorApply> {
-
-    /**
-     * 分页查询
-     *
-     * @param page  分页对象
-     * @param param 查询参数
-     * @return List<ClinicDoctorApply>
-     */
-    List<ClinicDoctorApply> selectPageRel(@Param("page") IPage<ClinicDoctorApply> page,
-                             @Param("param") ClinicDoctorApplyParam param);
-
-    /**
-     * 查询全部
-     *
-     * @param param 查询参数
-     * @return List<User>
-     */
-    List<ClinicDoctorApply> selectListRel(@Param("param") ClinicDoctorApplyParam param);
-
-}

src/main/java/com/gxwebsoft/clinic/mapper/ClinicDoctorUserMapper.java

@@ -1,37 +0,0 @@
-package com.gxwebsoft.clinic.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.gxwebsoft.clinic.entity.ClinicDoctorUser;
-import com.gxwebsoft.clinic.param.ClinicDoctorUserParam;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-/**
- * 分销商用户记录表Mapper
- *
- * @author 科技小王子
- * @since 2025-10-19 09:27:04
- */
-public interface ClinicDoctorUserMapper extends BaseMapper<ClinicDoctorUser> {
-
-    /**
-     * 分页查询
-     *
-     * @param page  分页对象
-     * @param param 查询参数
-     * @return List<ClinicDoctorUser>
-     */
-    List<ClinicDoctorUser> selectPageRel(@Param("page") IPage<ClinicDoctorUser> page,
-                             @Param("param") ClinicDoctorUserParam param);
-
-    /**
-     * 查询全部
-     *
-     * @param param 查询参数
-     * @return List<User>
-     */
-    List<ClinicDoctorUser> selectListRel(@Param("param") ClinicDoctorUserParam param);
-
-}

src/main/java/com/gxwebsoft/clinic/mapper/ClinicMedicineInoutMapper.java

@@ -1,37 +0,0 @@
-package com.gxwebsoft.clinic.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.gxwebsoft.clinic.entity.ClinicMedicineInout;
-import com.gxwebsoft.clinic.param.ClinicMedicineInoutParam;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-/**
- * 出入库Mapper
- *
- * @author 科技小王子
- * @since 2025-10-22 02:06:32
- */
-public interface ClinicMedicineInoutMapper extends BaseMapper<ClinicMedicineInout> {
-
-    /**
-     * 分页查询
-     *
-     * @param page  分页对象
-     * @param param 查询参数
-     * @return List<ClinicMedicineInout>
-     */
-    List<ClinicMedicineInout> selectPageRel(@Param("page") IPage<ClinicMedicineInout> page,
-                             @Param("param") ClinicMedicineInoutParam param);
-
-    /**
-     * 查询全部
-     *
-     * @param param 查询参数
-     * @return List<User>
-     */
-    List<ClinicMedicineInout> selectListRel(@Param("param") ClinicMedicineInoutParam param);
-
-}

src/main/java/com/gxwebsoft/clinic/mapper/ClinicMedicineMapper.java

@@ -1,37 +0,0 @@
-package com.gxwebsoft.clinic.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.gxwebsoft.clinic.entity.ClinicMedicine;
-import com.gxwebsoft.clinic.param.ClinicMedicineParam;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-/**
- * 药品库Mapper
- *
- * @author 科技小王子
- * @since 2025-10-22 02:06:31
- */
-public interface ClinicMedicineMapper extends BaseMapper<ClinicMedicine> {
-
-    /**
-     * 分页查询
-     *
-     * @param page  分页对象
-     * @param param 查询参数
-     * @return List<ClinicMedicine>
-     */
-    List<ClinicMedicine> selectPageRel(@Param("page") IPage<ClinicMedicine> page,
-                             @Param("param") ClinicMedicineParam param);
-
-    /**
-     * 查询全部
-     *
-     * @param param 查询参数
-     * @return List<User>
-     */
-    List<ClinicMedicine> selectListRel(@Param("param") ClinicMedicineParam param);
-
-}

src/main/java/com/gxwebsoft/clinic/mapper/ClinicMedicineStockMapper.java

@@ -1,37 +0,0 @@
-package com.gxwebsoft.clinic.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.gxwebsoft.clinic.entity.ClinicMedicineStock;
-import com.gxwebsoft.clinic.param.ClinicMedicineStockParam;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-/**
- * 药品库存Mapper
- *
- * @author 科技小王子
- * @since 2025-10-22 02:06:32
- */
-public interface ClinicMedicineStockMapper extends BaseMapper<ClinicMedicineStock> {
-
-    /**
-     * 分页查询
-     *
-     * @param page  分页对象
-     * @param param 查询参数
-     * @return List<ClinicMedicineStock>
-     */
-    List<ClinicMedicineStock> selectPageRel(@Param("page") IPage<ClinicMedicineStock> page,
-                             @Param("param") ClinicMedicineStockParam param);
-
-    /**
-     * 查询全部
-     *
-     * @param param 查询参数
-     * @return List<User>
-     */
-    List<ClinicMedicineStock> selectListRel(@Param("param") ClinicMedicineStockParam param);
-
-}

src/main/java/com/gxwebsoft/clinic/mapper/ClinicPatientUserMapper.java

@@ -1,37 +0,0 @@
-package com.gxwebsoft.clinic.mapper;
-
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.gxwebsoft.clinic.entity.ClinicPatientUser;
-import com.gxwebsoft.clinic.param.ClinicPatientUserParam;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-
-/**
- * 患者Mapper
- *
- * @author 科技小王子
- * @since 2025-10-19 09:27:04
- */
-public interface ClinicPatientUserMapper extends BaseMapper<ClinicPatientUser> {
-
-    /**
-     * 分页查询
-     *
-     * @param page  分页对象
-     * @param param 查询参数
-     * @return List<ClinicPatientUser>
-     */
-    List<ClinicPatientUser> selectPageRel(@Param("page") IPage<ClinicPatientUser> page,
-                             @Param("param") ClinicPatientUserParam param);
-
-    /**
-     * 查询全部
-     *
-     * @param param 查询参数
-     * @return List<User>
-     */
-    List<ClinicPatientUser> selectListRel(@Param("param") ClinicPatientUserParam param);
-
-}