Commit 8a9b5620 by renyizhao

阶段五完成

parent 2cb2a43f
package com.luhu.computility.module.apihub.api.apihub; package com.luhu.computility.module.apihub.api.apihub;
import com.luhu.computility.module.apihub.api.apihub.dto.ApiHubTopUpResultDTO;
import java.math.BigDecimal; import java.math.BigDecimal;
/** /**
...@@ -25,4 +27,22 @@ public interface ApiHubUserApi { ...@@ -25,4 +27,22 @@ public interface ApiHubUserApi {
*/ */
BigDecimal getQuotaYuan(Long apiHubUserId, String apiHubUsername); BigDecimal getQuotaYuan(Long apiHubUserId, String apiHubUsername);
/**
* 给 api_hub 网关用户充值额度
*
* <p>api_hub 的 {@code POST /api/users/{user_id}/topup} 有两个硬约束:
* <ul>
* <li>金额必须大于 0 —— 不支持负数,等于没有「扣减额度」的能力</li>
* <li>请求体必须带上当前管理员密码做二次确认</li>
* </ul>
*
* <p>失败时返回 {@code success=false} 并带失败原因,由调用方落库(充值失败明细不能丢)。
*
* @param apiHubUserId api_hub 用户 ID(对应 member_user.api_hub_user_id)
* @param amountYuan 充值额度(元),必须大于 0
* @param note 备注(api_hub 侧最多保留 200 字符)
* @return 充值结果
*/
ApiHubTopUpResultDTO topUp(Long apiHubUserId, BigDecimal amountYuan, String note);
} }
package com.luhu.computility.module.apihub.api.apihub.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* api_hub 额度充值结果
*
* <p>api_hub 的充值是「加额度」操作,没有撤销/回滚接口,失败原因必须原样带回给 puhui 侧落库,
* 故此处不抛异常,而是用 success + message 表达结果。
*
* @author puhui
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ApiHubTopUpResultDTO {
/**
* 是否充值成功
*/
private Boolean success;
/**
* 失败原因(成功时为空)
*/
private String message;
/**
* 充值后的余额(元),失败时为空
*/
private BigDecimal balanceYuan;
}
package com.luhu.computility.module.apihub.api.apihub; package com.luhu.computility.module.apihub.api.apihub;
import cn.hutool.core.util.StrUtil; import cn.hutool.core.util.StrUtil;
import com.luhu.computility.module.apihub.api.apihub.dto.ApiHubTopUpResultDTO;
import com.luhu.computility.module.apihub.config.ApiHubProperties; import com.luhu.computility.module.apihub.config.ApiHubProperties;
import com.luhu.computility.module.apihub.controller.admin.apihub.ApiHubResponse; import com.luhu.computility.module.apihub.controller.admin.apihub.ApiHubResponse;
import com.luhu.computility.module.apihub.controller.admin.apihub.ApiHubUserVO; import com.luhu.computility.module.apihub.controller.admin.apihub.ApiHubUserVO;
...@@ -65,4 +66,34 @@ public class ApiHubUserApiServiceImpl implements ApiHubUserApi { ...@@ -65,4 +66,34 @@ public class ApiHubUserApiServiceImpl implements ApiHubUserApi {
return null; return null;
} }
} }
@Override
public ApiHubTopUpResultDTO topUp(Long apiHubUserId, BigDecimal amountYuan, String note) {
if (apiHubUserId == null) {
return new ApiHubTopUpResultDTO(false, "用户尚未开通 api_hub 账号,无法发放额度", null);
}
if (amountYuan == null || amountYuan.compareTo(BigDecimal.ZERO) <= 0) {
return new ApiHubTopUpResultDTO(false, "额度必须大于 0", null);
}
try {
ApiHubResponse<ApiHubUserVO> resp = apiHubClient.topUpUser(apiHubUserId, amountYuan, note);
if (!Boolean.TRUE.equals(resp.getSuccess()) || resp.getData() == null) {
String message = StrUtil.isBlank(resp.getMessage()) ? "api_hub 充值失败" : resp.getMessage();
log.warn("[ApiHubUserApi.topUp] api_hub 充值失败, userId={}, message={}", apiHubUserId, message);
return new ApiHubTopUpResultDTO(false, message, null);
}
BigDecimal quota = resp.getData().getQuota() != null
? BigDecimal.valueOf(resp.getData().getQuota())
: BigDecimal.ZERO;
BigDecimal quotaPerYuan = apiHubProperties.getQuotaPerYuan();
if (quotaPerYuan == null || quotaPerYuan.compareTo(BigDecimal.ZERO) <= 0) {
quotaPerYuan = BigDecimal.ONE;
}
return new ApiHubTopUpResultDTO(true, null,
quota.divide(quotaPerYuan, 2, RoundingMode.HALF_UP));
} catch (Exception e) {
log.error("[ApiHubUserApi.topUp] api_hub 充值异常, userId={}", apiHubUserId, e);
return new ApiHubTopUpResultDTO(false, "充值异常: " + e.getMessage(), null);
}
}
} }
...@@ -111,11 +111,31 @@ public class ApiHubModelPriceVO { ...@@ -111,11 +111,31 @@ public class ApiHubModelPriceVO {
private String maxOutputLength; private String maxOutputLength;
/** /**
* 模型类型标签(text / multimodal / image_gen / video_gen / embedding / rerank / speech) * 模型类型标签
*
* <p><b>注意语义含混</b>:api_hub 的这个列既可能存内置模型类型 token
* (text / multimodal / image_gen / video_gen / embedding / rerank / speech),
* 也可能存支持模态 token(text / image / video / audio / vector / rerank)——
* 管理端「模型类型」多选的选项来自「支持模态选项」,后端写入时两者都允许。
* 解读时需按 {@code ApiHubCapabilityResolver} 统一归一化。
*/ */
private List<String> modalities; private List<String> modalities;
/** /**
* 输入模态(text / image / video / audio / vector / rerank)
*
* <p>这是 api_hub 运行时能力门禁(图像、视频模态校验)的真实依据。
*/
private List<String> inputModalities;
/**
* 输出模态(text / image / video / audio / vector / rerank)
*
* <p>决定模型「能产出什么」,是推导调用端点的主要依据。
*/
private List<String> outputModalities;
/**
* 是否在售 * 是否在售
* *
* <p>api_hub 这个字段类型不统一:已在「模型售价」里配置的行是数字 {@code 1}, * <p>api_hub 这个字段类型不统一:已在「模型售价」里配置的行是数字 {@code 1},
......
...@@ -126,7 +126,9 @@ public class AppModelPricingVO { ...@@ -126,7 +126,9 @@ public class AppModelPricingVO {
private String channelName; private String channelName;
/** /**
* 模型类型标签(text / multimodal / image_gen / video_gen / embedding / rerank / speech) * 模型能力类型(text / multimodal / image_gen / video_gen / embedding / rerank / speech)
*
* <p>由 api_hub 的 modalities / 输入输出模态归一化而来,口径与 api_hub 的模型类型一致。
*/ */
private List<String> modalities = new ArrayList<>(); private List<String> modalities = new ArrayList<>();
......
package com.luhu.computility.module.apihub.service.apihub;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
/**
* 模型能力归一化:把 api_hub 的三套模态字段统一成一套「能力类型」token
*
* <p>api_hub 侧字段语义:
* <ul>
* <li>{@code input_modalities} / {@code output_modalities}:模型真实的输入输出模态,
* 运行时能力门禁(图像 / 视频模态校验)就看这个,是最可靠的依据</li>
* <li>{@code modalities}:管理端「模型类型」列。它的选项来自「支持模态选项」,
* 所以实际存的可能是支持模态 token(text/image/video/audio/vector/rerank),
* 也可能是内置模型类型 token(text/multimodal/image_gen/video_gen/embedding/rerank/speech)
* —— 管理员不勾选时由 api_hub 按输入输出推导后写入后者</li>
* </ul>
*
* <p>本类把以上混合 token 统一成 api_hub 的内置能力类型 token
* (text / multimodal / image_gen / video_gen / embedding / rerank / speech),
* 供 puhui 的标签与简介使用。
*
* <p><b>注意</b>:本类的口径是「输出主导」,用来描述模型<b>是什么</b>(标签 / 简介);
* 而「调用端点」的口径是「输入 ∪ 输出」并集(见 {@link ApiHubEndpointRegistry}),
* 用来描述模型<b>能怎么调</b>。两者刻意分开:端点要跟 api_hub「接入示例」的
* 模态筛选保持一致,标签则要让人一眼看出模型的主用途。
*
* @author puhui
*/
@Component
public class ApiHubCapabilityResolver {
/**
* api_hub 内置模型类型 token
*/
public static final String TYPE_TEXT = "text";
public static final String TYPE_MULTIMODAL = "multimodal";
public static final String TYPE_IMAGE_GEN = "image_gen";
public static final String TYPE_VIDEO_GEN = "video_gen";
public static final String TYPE_EMBEDDING = "embedding";
public static final String TYPE_RERANK = "rerank";
public static final String TYPE_SPEECH = "speech";
public static final String TYPE_TRANSCRIPTION = "transcription";
/**
* 内置模型类型 token 集合
*/
private static final Set<String> MODEL_TYPE_TOKENS = new LinkedHashSet<>(List.of(
TYPE_TEXT, TYPE_MULTIMODAL, TYPE_IMAGE_GEN, TYPE_VIDEO_GEN,
TYPE_EMBEDDING, TYPE_RERANK, TYPE_SPEECH));
/**
* 支持模态 token → 能力类型 token
*
* <p>text 与 rerank 在两套 token 里同名同义,其余需转换:
* image→image_gen、video→video_gen、audio→speech、vector→embedding。
*/
private static final String[][] MODALITY_TO_TYPE = {
{"text", TYPE_TEXT},
{"image", TYPE_IMAGE_GEN},
{"video", TYPE_VIDEO_GEN},
{"audio", TYPE_SPEECH},
{"vector", TYPE_EMBEDDING},
{"rerank", TYPE_RERANK},
};
/**
* 归一化:由输入/输出模态推导出模型能力类型列表
*
* <p>口径与 api_hub 运行时保持一致:
* <ul>
* <li>api_hub 的模态门禁(图像 / 视频)看的是 {@code input_modalities} ∪
* {@code output_modalities},只有这两个字段决定模型实际能走哪个端点、
* 按哪种价目计费</li>
* <li>{@code modalities}(模型类型列)不参与 api_hub 的门禁与计费,只是对外
* {@code /v1/models} 发布的粗粒度标签,因此**不参与端点推导**,
* 只在输入/输出模态都没配时才用来兜底</li>
* </ul>
*
* @param modalities api_hub 的模型类型列(语义含混,模态 token 与类型 token 都可能出现)
* @param inputModalities 输入模态
* @param outputModalities 输出模态
* @return 能力类型 token 列表(有序、去重);无法判定时返回空列表
*/
public List<String> resolve(List<String> modalities,
List<String> inputModalities,
List<String> outputModalities) {
Set<String> types = new LinkedHashSet<>();
List<String> in = nullSafe(inputModalities);
List<String> out = nullSafe(outputModalities);
if (in.isEmpty() && out.isEmpty()) {
// 输入/输出模态都没配:api_hub 的模态门禁此时不拦(回落到渠道级能力选路),
// 只能靠管理员标注的模型类型兜底给个方向
for (String modality : nullSafe(modalities)) {
String type = toCapabilityType(modality);
if (type != null) {
types.add(type);
}
}
return new ArrayList<>(types);
}
// ① 输出模态决定「能产出什么」,是能力的主要来源
for (String modality : out) {
String type = toCapabilityType(modality);
if (type != null) {
types.add(type);
}
}
// ② 输出没配但输入是文本时,按对话模型处理
if (out.isEmpty() && contains(in, "text")) {
types.add(TYPE_TEXT);
}
// ③ 输入模态决定「能理解什么」:只有在能产出文本时才体现为多模态
boolean outputText = out.isEmpty() || contains(out, "text");
if (outputText) {
for (String modality : in) {
if (isTextLike(modality)) {
continue;
}
types.add(TYPE_MULTIMODAL);
}
}
// ④ 输入含音频 = 能听懂语音(语音识别,语音 → 文本),与「能产出语音」是两回事
if (contains(in, "audio")) {
types.add(TYPE_TRANSCRIPTION);
}
return new ArrayList<>(types);
}
/**
* null 安全取值
*/
private List<String> nullSafe(List<String> values) {
return values == null ? Collections.emptyList() : values;
}
/**
* token → 能力类型
*
* @return 能力类型 token;token 无法识别时返回 null
*/
private String toCapabilityType(String token) {
if (token == null) {
return null;
}
String text = token.trim().toLowerCase();
if (text.isEmpty()) {
return null;
}
if (MODEL_TYPE_TOKENS.contains(text)) {
return text;
}
for (String[] pair : MODALITY_TO_TYPE) {
if (pair[0].equals(text)) {
return pair[1];
}
}
return null;
}
private boolean isTextLike(String modality) {
if (modality == null) {
return true;
}
String text = modality.trim().toLowerCase();
return text.isEmpty() || "text".equals(text);
}
private boolean contains(Collection<String> values, String target) {
if (values == null) {
return false;
}
for (String value : values) {
if (value != null && target.equalsIgnoreCase(value.trim())) {
return true;
}
}
return false;
}
}
...@@ -16,6 +16,7 @@ import lombok.extern.slf4j.Slf4j; ...@@ -16,6 +16,7 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.math.BigDecimal;
import java.net.URI; import java.net.URI;
import java.net.URLEncoder; import java.net.URLEncoder;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
...@@ -368,6 +369,31 @@ public class ApiHubClient { ...@@ -368,6 +369,31 @@ public class ApiHubClient {
} }
/** /**
* 给 api_hub 用户充值额度
*
* <p>api_hub 的 {@code POST /api/users/{user_id}/topup} 有几条硬约束:
* <ul>
* <li>金额必须大于 0(不支持负数,等于没有「扣减额度」的能力)</li>
* <li>请求体必须带当前管理员密码做二次确认(api_hub 的 {@code _require_admin_password})</li>
* <li>额度记到用户所属企业成员行,没有企业则记 {@code users.quota},单位是「元」</li>
* <li>同时写一条 {@code recharge_logs} 流水(type=admin_topup)</li>
* </ul>
*
* @param userId api_hub 用户 ID
* @param amountYuan 充值额度(元),必须大于 0
* @param note 备注,api_hub 侧最多保留 200 字符
*/
public ApiHubResponse<ApiHubUserVO> topUpUser(Long userId, BigDecimal amountYuan, String note) {
String url = apiHubProperties.getBaseUrl() + "/api/users/" + userId + "/topup";
Map<String, Object> body = new HashMap<>();
body.put("amount", amountYuan);
body.put("note", StrUtil.subPre(StrUtil.nullToEmpty(note), 200));
body.put("password", apiHubProperties.getAdminPassword());
log.info("[ApiHubClient.topUpUser] 请求URL: {}, userId={}, amount={}", url, userId, amountYuan);
return executeJson(url, body, ApiHubUserVO.class);
}
/**
* 按用户名查询 api_hub 用户 * 按用户名查询 api_hub 用户
* *
* <p>用于创建用户返回 409「用户名已存在」后续建:先查已有用户拿到 user_id 再继续签发密钥。 * <p>用于创建用户返回 409「用户名已存在」后续建:先查已有用户拿到 user_id 再继续签发密钥。
......
...@@ -16,32 +16,40 @@ public enum ApiHubEndpoint { ...@@ -16,32 +16,40 @@ public enum ApiHubEndpoint {
/** /**
* 对话补全(OpenAI 兼容) * 对话补全(OpenAI 兼容)
*/ */
CHAT("chat", "对话补全", "/v1/chat/completions", "chat.completions.create"), CHAT("chat", "对话补全", "/v1/chat/completions", "chat.completions.create", false),
/** /**
* 向量嵌入 * 向量嵌入
*/ */
EMBEDDINGS("embeddings", "向量嵌入", "/v1/embeddings", "embeddings.create"), EMBEDDINGS("embeddings", "向量嵌入", "/v1/embeddings", "embeddings.create", false),
/** /**
* 文本重排 * 文本重排
*/ */
RERANK("rerank", "文本重排", "/v1/rerank", null), RERANK("rerank", "文本重排", "/v1/rerank", null, false),
/** /**
* 图像生成 * 图像生成
*/ */
IMAGES("images", "图像生成", "/v1/images/generations", "images.generate"), IMAGES("images", "图像生成", "/v1/images/generations", "images.generate", false),
/** /**
* 视频生成 * 视频生成
*/ */
VIDEOS("videos", "视频生成", "/v1/videos/generations", null), VIDEOS("videos", "视频生成", "/v1/videos/generations", null, false),
/** /**
* 语音合成 * 语音合成(文本 → 语音)
*/ */
AUDIO("audio", "语音合成", "/v1/audio/speech", null); AUDIO_SPEECH("audio-speech", "语音合成", "/v1/audio/speech", "audio.speech.create", false),
/**
* 语音识别(语音 → 文本)
*
* <p>与语音合成方向相反:请求体是 multipart/form-data,必须携带音频文件字段
* {@code file},不能像其它端点那样用 JSON 描述。
*/
AUDIO_TRANSCRIPTIONS("audio-transcriptions", "语音识别", "/v1/audio/transcriptions", "audio.transcriptions.create", true);
/** /**
* 端点标识 * 端点标识
...@@ -64,11 +72,17 @@ public enum ApiHubEndpoint { ...@@ -64,11 +72,17 @@ public enum ApiHubEndpoint {
*/ */
private final String sdkMethod; private final String sdkMethod;
ApiHubEndpoint(String id, String name, String path, String sdkMethod) { /**
* 是否为 multipart 上传型端点(请求体要带文件,不能用 JSON 描述)
*/
private final boolean multipart;
ApiHubEndpoint(String id, String name, String path, String sdkMethod, boolean multipart) {
this.id = id; this.id = id;
this.name = name; this.name = name;
this.path = path; this.path = path;
this.sdkMethod = sdkMethod; this.sdkMethod = sdkMethod;
this.multipart = multipart;
} }
public String getId() { public String getId() {
...@@ -93,4 +107,11 @@ public enum ApiHubEndpoint { ...@@ -93,4 +107,11 @@ public enum ApiHubEndpoint {
public boolean isSdkSupported() { public boolean isSdkSupported() {
return sdkMethod != null; return sdkMethod != null;
} }
/**
* 是否是 multipart 上传型端点
*/
public boolean isMultipart() {
return multipart;
}
} }
...@@ -3,18 +3,25 @@ package com.luhu.computility.module.apihub.service.apihub; ...@@ -3,18 +3,25 @@ package com.luhu.computility.module.apihub.service.apihub;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
* 端点注册表:模型类型 → 端点,以及各端点的请求体模板 * 端点注册表:模型模态 → 端点,以及各端点的请求体模板
* *
* <p>模型类型取自 api_hub 的 {@code model_prices.modalities}(api_hub 内部叫「模型类型」, * <p>端点由 api_hub 的输入 / 输出模态决定,口径与 api_hub 管理端「模型」页的
* 取值与 {@code db.MODEL_TYPE_LABELS} 一致)。一个对外模型 id 可能同时带多个类型 * 「接入示例」一致:<b>输入或输出任一含该模态即命中</b>(api_hub 前端
* (同一行配多个类型,或跨渠道合并),因此这里返回的是端点列表而不是单个端点。 * {@code app.js} 的模态筛选就是按 {@code input_modalities ∪ output_modalities} 匹配的)。
*
* <p>唯一的例外是两个音频端点,它们方向相反,不能用并集判定:
* <ul>
* <li>语音合成 {@code /v1/audio/speech}:文本 → 语音,看<b>输出</b>含不含 audio</li>
* <li>语音识别 {@code /v1/audio/transcriptions}:语音 → 文本,看<b>输入</b>含不含 audio</li>
* </ul>
*
* <p>一个模型可能命中多个端点(如既能对话又能生成图片),因此返回的是端点列表。
* *
* @author puhui * @author puhui
*/ */
...@@ -22,9 +29,32 @@ import java.util.Map; ...@@ -22,9 +29,32 @@ import java.util.Map;
public class ApiHubEndpointRegistry { public class ApiHubEndpointRegistry {
/** /**
* 模型类型 → 端点。api_hub 的七类模型类型里,multimodal 与 text 走同一个对话端点。 * 模态命中方向
*/
private enum Scope {
/**
* 输入或输出任一含该模态即命中
*/
EITHER,
/**
* 只看输入模态
*/
INPUT,
/**
* 只看输出模态
*/
OUTPUT
}
/**
* 端点 → 命中规则(按 api_hub「接入示例」的模态分类顺序排列)
*/
private static final Map<ApiHubEndpoint, String[]> ENDPOINT_RULES = new LinkedHashMap<>();
/**
* 端点 → 命中方向
*/ */
private static final Map<String, ApiHubEndpoint> TYPE_ENDPOINT_MAP = new LinkedHashMap<>(); private static final Map<ApiHubEndpoint, Scope> ENDPOINT_SCOPES = new LinkedHashMap<>();
/** /**
* 各端点的请求体模板(JSON 缩进格式,{@code {{model}}} 会被替换成对外模型 id) * 各端点的请求体模板(JSON 缩进格式,{@code {{model}}} 会被替换成对外模型 id)
...@@ -43,13 +73,21 @@ public class ApiHubEndpointRegistry { ...@@ -43,13 +73,21 @@ public class ApiHubEndpointRegistry {
private static final Map<ApiHubEndpoint, String[]> RESPONSE_HINTS = new LinkedHashMap<>(); private static final Map<ApiHubEndpoint, String[]> RESPONSE_HINTS = new LinkedHashMap<>();
static { static {
TYPE_ENDPOINT_MAP.put("text", ApiHubEndpoint.CHAT); // 文本 → 图像 → 视频 → 向量 → 音频,与 api_hub「接入示例」的 Tab 顺序一致
TYPE_ENDPOINT_MAP.put("multimodal", ApiHubEndpoint.CHAT); ENDPOINT_RULES.put(ApiHubEndpoint.CHAT, new String[]{"text"});
TYPE_ENDPOINT_MAP.put("embedding", ApiHubEndpoint.EMBEDDINGS); ENDPOINT_SCOPES.put(ApiHubEndpoint.CHAT, Scope.EITHER);
TYPE_ENDPOINT_MAP.put("rerank", ApiHubEndpoint.RERANK); ENDPOINT_RULES.put(ApiHubEndpoint.IMAGES, new String[]{"image"});
TYPE_ENDPOINT_MAP.put("image_gen", ApiHubEndpoint.IMAGES); ENDPOINT_SCOPES.put(ApiHubEndpoint.IMAGES, Scope.EITHER);
TYPE_ENDPOINT_MAP.put("video_gen", ApiHubEndpoint.VIDEOS); ENDPOINT_RULES.put(ApiHubEndpoint.VIDEOS, new String[]{"video"});
TYPE_ENDPOINT_MAP.put("speech", ApiHubEndpoint.AUDIO); ENDPOINT_SCOPES.put(ApiHubEndpoint.VIDEOS, Scope.EITHER);
ENDPOINT_RULES.put(ApiHubEndpoint.EMBEDDINGS, new String[]{"vector"});
ENDPOINT_SCOPES.put(ApiHubEndpoint.EMBEDDINGS, Scope.EITHER);
ENDPOINT_RULES.put(ApiHubEndpoint.RERANK, new String[]{"rerank"});
ENDPOINT_SCOPES.put(ApiHubEndpoint.RERANK, Scope.EITHER);
ENDPOINT_RULES.put(ApiHubEndpoint.AUDIO_SPEECH, new String[]{"audio"});
ENDPOINT_SCOPES.put(ApiHubEndpoint.AUDIO_SPEECH, Scope.OUTPUT);
ENDPOINT_RULES.put(ApiHubEndpoint.AUDIO_TRANSCRIPTIONS, new String[]{"audio"});
ENDPOINT_SCOPES.put(ApiHubEndpoint.AUDIO_TRANSCRIPTIONS, Scope.INPUT);
BODY_TEMPLATES.put(ApiHubEndpoint.CHAT, "{\n" BODY_TEMPLATES.put(ApiHubEndpoint.CHAT, "{\n"
+ " \"model\": \"{{model}}\",\n" + " \"model\": \"{{model}}\",\n"
...@@ -92,7 +130,7 @@ public class ApiHubEndpointRegistry { ...@@ -92,7 +130,7 @@ public class ApiHubEndpointRegistry {
+ " \"ratio\": \"16:9\"\n" + " \"ratio\": \"16:9\"\n"
+ "}"); + "}");
BODY_TEMPLATES.put(ApiHubEndpoint.AUDIO, "{\n" BODY_TEMPLATES.put(ApiHubEndpoint.AUDIO_SPEECH, "{\n"
+ " \"model\": \"{{model}}\",\n" + " \"model\": \"{{model}}\",\n"
+ " \"input\": \"你好,这是一段语音合成示例。\",\n" + " \"input\": \"你好,这是一段语音合成示例。\",\n"
+ " \"voice\": \"Cherry\"\n" + " \"voice\": \"Cherry\"\n"
...@@ -100,20 +138,17 @@ public class ApiHubEndpointRegistry { ...@@ -100,20 +138,17 @@ public class ApiHubEndpointRegistry {
} }
/** /**
* 按模型类型解析端点列表 * 按输入 / 输出模态解析端点列表
* *
* @param modelTypes 模型类型集合(api_hub 的 modalities),可为空 * @param inputModalities api_hub 的输入模态
* @return 端点列表,按注册表固定顺序去重 * @param outputModalities api_hub 的输出模态
* @return 端点列表,按注册表固定顺序去重;一个模态都没配时按最常见的对话模型处理
*/ */
public List<ApiHubEndpoint> resolveEndpoints(Collection<String> modelTypes) { public List<ApiHubEndpoint> resolveEndpoints(List<String> inputModalities, List<String> outputModalities) {
if (modelTypes == null || modelTypes.isEmpty()) {
// 模型类型缺失时按最常见的对话模型处理
return Collections.singletonList(ApiHubEndpoint.CHAT);
}
List<ApiHubEndpoint> endpoints = new ArrayList<>(); List<ApiHubEndpoint> endpoints = new ArrayList<>();
for (Map.Entry<String, ApiHubEndpoint> entry : TYPE_ENDPOINT_MAP.entrySet()) { for (Map.Entry<ApiHubEndpoint, String[]> entry : ENDPOINT_RULES.entrySet()) {
if (!endpoints.contains(entry.getValue()) && containsIgnoreCase(modelTypes, entry.getKey())) { if (matches(entry.getKey(), inputModalities, outputModalities)) {
endpoints.add(entry.getValue()); endpoints.add(entry.getKey());
} }
} }
if (endpoints.isEmpty()) { if (endpoints.isEmpty()) {
...@@ -123,7 +158,40 @@ public class ApiHubEndpointRegistry { ...@@ -123,7 +158,40 @@ public class ApiHubEndpointRegistry {
} }
/** /**
* 取端点的请求体模板 * 端点是否命中该模型的模态
*/
private boolean matches(ApiHubEndpoint endpoint, List<String> inputModalities, List<String> outputModalities) {
String[] required = ENDPOINT_RULES.get(endpoint);
Scope scope = ENDPOINT_SCOPES.get(endpoint);
if (required == null || required.length == 0) {
return false;
}
String modality = required[0];
switch (scope) {
case INPUT:
return contains(inputModalities, modality);
case OUTPUT:
return contains(outputModalities, modality);
case EITHER:
default:
return contains(inputModalities, modality) || contains(outputModalities, modality);
}
}
private boolean contains(List<String> values, String target) {
if (values == null) {
return false;
}
for (String value : values) {
if (value != null && target.equalsIgnoreCase(value.trim())) {
return true;
}
}
return false;
}
/**
* 取端点的请求体模板;multipart 上传型端点没有 JSON 模板
*/ */
public String bodyTemplate(ApiHubEndpoint endpoint) { public String bodyTemplate(ApiHubEndpoint endpoint) {
return BODY_TEMPLATES.get(endpoint); return BODY_TEMPLATES.get(endpoint);
...@@ -137,20 +205,11 @@ public class ApiHubEndpointRegistry { ...@@ -137,20 +205,11 @@ public class ApiHubEndpointRegistry {
return hints == null ? new String[0] : hints; return hints == null ? new String[0] : hints;
} }
private boolean containsIgnoreCase(Collection<String> values, String target) {
for (String value : values) {
if (value != null && value.trim().equalsIgnoreCase(target)) {
return true;
}
}
return false;
}
/** /**
* 供测试与文档使用:全部模型类型 * 供测试与文档使用:全部端点
*/ */
public List<String> allModelTypes() { public List<ApiHubEndpoint> allEndpoints() {
return Collections.unmodifiableList(new ArrayList<>(TYPE_ENDPOINT_MAP.keySet())); return Collections.unmodifiableList(new ArrayList<>(ENDPOINT_RULES.keySet()));
} }
} }
...@@ -65,6 +65,9 @@ public class ApiHubModelPriceService { ...@@ -65,6 +65,9 @@ public class ApiHubModelPriceService {
@Resource @Resource
private ApiHubUsageService apiHubUsageService; private ApiHubUsageService apiHubUsageService;
@Resource
private ApiHubCapabilityResolver capabilityResolver;
/** /**
* 查询 api_hub 在售模型列表与价格 * 查询 api_hub 在售模型列表与价格
* *
...@@ -88,13 +91,20 @@ public class ApiHubModelPriceService { ...@@ -88,13 +91,20 @@ public class ApiHubModelPriceService {
} }
} }
// ② 同一对外模型 id 多渠道时,取输入实付价最低的那条 // ② 同一对外模型 id 多渠道时,取输入实付价最低的那条作为价格基准;
// 同时把各渠道声明的模态合并(与 api_hub available_model_io_modalities 的跨渠道合并口径一致)
Map<String, ApiHubModelPriceVO> best = new LinkedHashMap<>(); Map<String, ApiHubModelPriceVO> best = new LinkedHashMap<>();
Map<String, List<String>> mergedModalities = new LinkedHashMap<>();
Map<String, List<String>> mergedInput = new LinkedHashMap<>();
Map<String, List<String>> mergedOutput = new LinkedHashMap<>();
for (ApiHubModelPriceVO row : sellable) { for (ApiHubModelPriceVO row : sellable) {
String key = displayModelId(row); String key = displayModelId(row);
if (StrUtil.isBlank(key)) { if (StrUtil.isBlank(key)) {
continue; continue;
} }
mergeDistinct(mergedModalities, key, row.getModalities());
mergeDistinct(mergedInput, key, row.getInputModalities());
mergeDistinct(mergedOutput, key, row.getOutputModalities());
ApiHubModelPriceVO exists = best.get(key); ApiHubModelPriceVO exists = best.get(key);
if (exists == null if (exists == null
|| netPrice(row.getInputPrice(), row, userMultiplier) < netPrice(exists.getInputPrice(), exists, userMultiplier)) { || netPrice(row.getInputPrice(), row, userMultiplier) < netPrice(exists.getInputPrice(), exists, userMultiplier)) {
...@@ -104,14 +114,34 @@ public class ApiHubModelPriceService { ...@@ -104,14 +114,34 @@ public class ApiHubModelPriceService {
// ③ 组装返回 // ③ 组装返回
List<AppModelPricingVO> result = new ArrayList<>(best.size()); List<AppModelPricingVO> result = new ArrayList<>(best.size());
for (ApiHubModelPriceVO row : best.values()) { for (Map.Entry<String, ApiHubModelPriceVO> entry : best.entrySet()) {
result.add(toModelPricing(row, userMultiplier)); String key = entry.getKey();
result.add(toModelPricing(entry.getValue(), userMultiplier,
mergedModalities.get(key), mergedInput.get(key), mergedOutput.get(key)));
} }
result.sort(Comparator.comparing(AppModelPricingVO::getModelName, String.CASE_INSENSITIVE_ORDER)); result.sort(Comparator.comparing(AppModelPricingVO::getModelName, String.CASE_INSENSITIVE_ORDER));
return result; return result;
} }
/** /**
* 把一行的模态并入该对外模型 id 的合并集合(去重保序)
*/
private void mergeDistinct(Map<String, List<String>> target, String key, List<String> values) {
if (values == null || values.isEmpty()) {
return;
}
List<String> merged = target.computeIfAbsent(key, k -> new ArrayList<>());
for (String value : values) {
if (value == null || value.trim().isEmpty()) {
continue;
}
if (!merged.contains(value.trim())) {
merged.add(value.trim());
}
}
}
/**
* 是否在售:api_hub 用 enabled=1 表示在售,被系统自动隔离的模型不展示 * 是否在售:api_hub 用 enabled=1 表示在售,被系统自动隔离的模型不展示
*/ */
private boolean isSellable(ApiHubModelPriceVO row) { private boolean isSellable(ApiHubModelPriceVO row) {
...@@ -181,18 +211,29 @@ public class ApiHubModelPriceService { ...@@ -181,18 +211,29 @@ public class ApiHubModelPriceService {
return BigDecimal.valueOf(netPrice(configured, row, userPriceMultiplier)).setScale(4, RoundingMode.HALF_UP); return BigDecimal.valueOf(netPrice(configured, row, userPriceMultiplier)).setScale(4, RoundingMode.HALF_UP);
} }
private AppModelPricingVO toModelPricing(ApiHubModelPriceVO row, double userPriceMultiplier) { private AppModelPricingVO toModelPricing(ApiHubModelPriceVO row, double userPriceMultiplier,
List<String> mergedModalities, List<String> mergedInput,
List<String> mergedOutput) {
AppModelPricingVO vo = new AppModelPricingVO(); AppModelPricingVO vo = new AppModelPricingVO();
String modelId = displayModelId(row); String modelId = displayModelId(row);
vo.setModelName(modelId); vo.setModelName(modelId);
vo.setIcon(resolveIconByName(modelId)); vo.setIcon(resolveIconByName(modelId));
vo.setVendorName(resolveVendorName(modelId)); vo.setVendorName(resolveVendorName(modelId));
vo.setDescription(resolveDescription(row));
vo.setTags(resolveTags(row));
vo.setModalities(row.getModalities() == null ? new ArrayList<>() : row.getModalities());
// 使用方法:端点由模型类型映射,一个模型可能带多个类型 → 多条使用说明 // 能力归一化:api_hub 的 modalities 语义含混(可能是模态 token,也可能是模型类型 token),
List<AppModelUsageVO> usageMethods = apiHubUsageService.buildUsageMethods(modelId, vo.getModalities()); // 统一换成内置能力类型 token 后再用于标签、简介与端点映射
List<String> capabilities = capabilityResolver.resolve(mergedModalities, mergedInput, mergedOutput);
if (capabilities.isEmpty()) {
// 三个字段都没配时按最常见的对话模型处理
capabilities = Collections.singletonList(ApiHubCapabilityResolver.TYPE_TEXT);
}
vo.setModalities(capabilities);
vo.setDescription(resolveDescription(capabilities));
vo.setTags(resolveTags(capabilities));
// 使用方法:端点由输入 / 输出模态决定(与 api_hub「接入示例」的模态筛选同口径),
// 一个模型可能命中多个模态 → 多条使用说明
List<AppModelUsageVO> usageMethods = apiHubUsageService.buildUsageMethods(modelId, mergedInput, mergedOutput);
vo.setUsageMethods(usageMethods); vo.setUsageMethods(usageMethods);
vo.setSupportedEndpoints(usageMethods.stream() vo.setSupportedEndpoints(usageMethods.stream()
.map(AppModelUsageVO::getEndpoint) .map(AppModelUsageVO::getEndpoint)
...@@ -220,7 +261,7 @@ public class ApiHubModelPriceService { ...@@ -220,7 +261,7 @@ public class ApiHubModelPriceService {
vo.setVideoPrice720p(video720p); vo.setVideoPrice720p(video720p);
vo.setVideoPrice1080p(video1080p); vo.setVideoPrice1080p(video1080p);
String priceType = resolvePriceType(row, inputPrice, outputPrice, imagePrice, String priceType = resolvePriceType(capabilities, inputPrice, outputPrice, imagePrice,
video480p, video720p, video1080p); video480p, video720p, video1080p);
vo.setPriceType(priceType); vo.setPriceType(priceType);
switch (priceType) { switch (priceType) {
...@@ -241,10 +282,10 @@ public class ApiHubModelPriceService { ...@@ -241,10 +282,10 @@ public class ApiHubModelPriceService {
/** /**
* 判定价格类型 * 判定价格类型
* *
* <p>优先看是否配了视频分档价;没有 token 价时才按图片/视频模型类型归类; * <p>优先看是否配了视频分档价;没有 token 价时才按图片/视频能力归类;
* 其余按 token 计费。 * 其余按 token 计费。
*/ */
private String resolvePriceType(ApiHubModelPriceVO row, BigDecimal inputPrice, BigDecimal outputPrice, private String resolvePriceType(List<String> capabilities, BigDecimal inputPrice, BigDecimal outputPrice,
BigDecimal imagePrice, BigDecimal video480p, BigDecimal video720p, BigDecimal imagePrice, BigDecimal video480p, BigDecimal video720p,
BigDecimal video1080p) { BigDecimal video1080p) {
if (video480p != null || video720p != null || video1080p != null) { if (video480p != null || video720p != null || video1080p != null) {
...@@ -252,31 +293,25 @@ public class ApiHubModelPriceService { ...@@ -252,31 +293,25 @@ public class ApiHubModelPriceService {
} }
boolean noTokenPrice = (inputPrice == null && outputPrice == null); boolean noTokenPrice = (inputPrice == null && outputPrice == null);
if (noTokenPrice) { if (noTokenPrice) {
if (imagePrice != null || hasType(row, "image_gen")) { if (imagePrice != null || capabilities.contains(ApiHubCapabilityResolver.TYPE_IMAGE_GEN)) {
return PRICE_TYPE_PER_IMAGE; return PRICE_TYPE_PER_IMAGE;
} }
if (hasType(row, "video_gen")) { if (capabilities.contains(ApiHubCapabilityResolver.TYPE_VIDEO_GEN)) {
return PRICE_TYPE_PER_VIDEO; return PRICE_TYPE_PER_VIDEO;
} }
} }
return PRICE_TYPE_METERED; return PRICE_TYPE_METERED;
} }
private boolean hasType(ApiHubModelPriceVO row, String type) {
List<String> modalities = row.getModalities();
return modalities != null && modalities.contains(type);
}
/** /**
* api_hub 没有模型描述字段,这里按模型类型生成一句简短说明 * api_hub 没有模型描述字段,这里按模型能力生成一句简短说明
*/ */
private String resolveDescription(ApiHubModelPriceVO row) { private String resolveDescription(List<String> capabilities) {
List<String> modalities = row.getModalities(); if (capabilities == null || capabilities.isEmpty()) {
if (modalities == null || modalities.isEmpty()) {
return "文本对话模型"; return "文本对话模型";
} }
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
for (String type : modalities) { for (String type : capabilities) {
String label = typeDescLabel(type); String label = typeDescLabel(type);
if (label == null) { if (label == null) {
continue; continue;
...@@ -290,15 +325,14 @@ public class ApiHubModelPriceService { ...@@ -290,15 +325,14 @@ public class ApiHubModelPriceService {
} }
/** /**
* 标签取模型类型,便于前端筛选 * 标签取模型能力,便于前端筛选
*/ */
private String resolveTags(ApiHubModelPriceVO row) { private String resolveTags(List<String> capabilities) {
List<String> modalities = row.getModalities(); if (capabilities == null || capabilities.isEmpty()) {
if (modalities == null || modalities.isEmpty()) {
return null; return null;
} }
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
for (String type : modalities) { for (String type : capabilities) {
String label = typeLabel(type); String label = typeLabel(type);
if (label == null) { if (label == null) {
continue; continue;
...@@ -332,7 +366,9 @@ public class ApiHubModelPriceService { ...@@ -332,7 +366,9 @@ public class ApiHubModelPriceService {
case "rerank": case "rerank":
return "文本重排模型"; return "文本重排模型";
case "speech": case "speech":
return "语音模型"; return "语音合成模型";
case "transcription":
return "语音识别模型";
default: default:
return null; return null;
} }
...@@ -359,7 +395,9 @@ public class ApiHubModelPriceService { ...@@ -359,7 +395,9 @@ public class ApiHubModelPriceService {
case "rerank": case "rerank":
return "文本重排"; return "文本重排";
case "speech": case "speech":
return "语音"; return "语音合成";
case "transcription":
return "语音识别";
default: default:
return null; return null;
} }
......
...@@ -46,9 +46,22 @@ public class ApiHubSampleBuilder { ...@@ -46,9 +46,22 @@ public class ApiHubSampleBuilder {
String base = normalizeBase(apiBase); String base = normalizeBase(apiBase);
String openAiBaseUrl = base + "/v1"; String openAiBaseUrl = base + "/v1";
String url = base + endpoint.getPath(); String url = base + endpoint.getPath();
String body = endpointRegistry.bodyTemplate(endpoint).replace("{{model}}", modelName);
List<AppModelSampleVO> samples = new ArrayList<>(); List<AppModelSampleVO> samples = new ArrayList<>();
if (endpoint.isMultipart()) {
// multipart 上传型端点(语音识别):请求体要带文件,不能用 JSON 模板渲染
samples.add(AppModelSampleVO.builder()
.language("curl").title("cURL").code(buildMultipartCurl(url, modelName)).build());
samples.add(AppModelSampleVO.builder()
.language("python").title("Python").code(buildMultipartPython(modelName, openAiBaseUrl)).build());
samples.add(AppModelSampleVO.builder()
.language("typescript").title("TypeScript").code(buildMultipartEsm(modelName, openAiBaseUrl)).build());
samples.add(AppModelSampleVO.builder()
.language("javascript").title("JavaScript").code(buildMultipartEsm(modelName, openAiBaseUrl)).build());
return samples;
}
String body = endpointRegistry.bodyTemplate(endpoint).replace("{{model}}", modelName);
samples.add(AppModelSampleVO.builder() samples.add(AppModelSampleVO.builder()
.language("curl").title("cURL").code(buildCurl(url, body)).build()); .language("curl").title("cURL").code(buildCurl(url, body)).build());
samples.add(AppModelSampleVO.builder() samples.add(AppModelSampleVO.builder()
...@@ -61,6 +74,49 @@ public class ApiHubSampleBuilder { ...@@ -61,6 +74,49 @@ public class ApiHubSampleBuilder {
} }
/** /**
* 拼 multipart 上传型端点的 cURL 示例
*/
private String buildMultipartCurl(String url, String modelName) {
return "curl -X POST \"" + url + "\" \\\n"
+ " -H \"Authorization: Bearer " + API_KEY_PLACEHOLDER + "\" \\\n"
+ " -F \"file=@audio.mp3\" \\\n"
+ " -F \"model=" + modelName + "\"";
}
/**
* 拼 multipart 上传型端点的 Python 示例(OpenAI SDK)
*/
private String buildMultipartPython(String modelName, String openAiBaseUrl) {
return "from openai import OpenAI\n\n"
+ "client = OpenAI(api_key=\"" + API_KEY_PLACEHOLDER + "\", base_url=\"" + openAiBaseUrl + "\")\n\n"
+ "with open(\"audio.mp3\", \"rb\") as f:\n"
+ " response = client.audio.transcriptions.create(\n"
+ " model=\"" + modelName + "\",\n"
+ " file=f,\n"
+ " )\n"
+ "print(response.text)";
}
/**
* 拼 multipart 上传型端点的 TypeScript / JavaScript 示例(OpenAI SDK)
*/
private String buildMultipartEsm(String modelName, String openAiBaseUrl) {
StringBuilder sb = new StringBuilder();
sb.append("import OpenAI from \"openai\";\n");
sb.append("import fs from \"fs\";\n\n");
sb.append("const client = new OpenAI({\n");
sb.append(" apiKey: \"").append(API_KEY_PLACEHOLDER).append("\",\n");
sb.append(" baseURL: \"").append(openAiBaseUrl).append("\",\n");
sb.append("});\n\n");
sb.append("const response = await client.audio.transcriptions.create({\n");
sb.append(" model: \"").append(modelName).append("\",\n");
sb.append(" file: fs.createReadStream(\"audio.mp3\"),\n");
sb.append("});\n");
sb.append("console.log(response.text);");
return sb.toString();
}
/**
* 拼 cURL 示例 * 拼 cURL 示例
*/ */
private String buildCurl(String url, String body) { private String buildCurl(String url, String body) {
......
...@@ -7,7 +7,6 @@ import org.springframework.stereotype.Service; ...@@ -7,7 +7,6 @@ import org.springframework.stereotype.Service;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection;
import java.util.List; import java.util.List;
/** /**
...@@ -15,8 +14,8 @@ import java.util.List; ...@@ -15,8 +14,8 @@ import java.util.List;
* *
* <p>规则: * <p>规则:
* <ol> * <ol>
* <li>端点由 api_hub 的模型类型({@code model_prices.modalities})映射而来, * <li>端点由 api_hub 的输入 / 输出模态决定(口径与 api_hub「接入示例」的模态筛选一致:
* 一个模型带多个类型时会有多条使用说明</li> * 输入或输出任一含该模态即命中),一个模型命中多个模态时会有多条使用说明</li>
* <li>base_url 取 puhui 自己配置的 api_hub 对外地址,不额外调 api_hub 的对外接口</li> * <li>base_url 取 puhui 自己配置的 api_hub 对外地址,不额外调 api_hub 的对外接口</li>
* <li>示例代码里的模型名用对外 id(api_hub 配了别名时是别名)</li> * <li>示例代码里的模型名用对外 id(api_hub 配了别名时是别名)</li>
* <li>参数说明由 puhui 侧静态配置维护,只列 api_hub 自身有语义的参数</li> * <li>参数说明由 puhui 侧静态配置维护,只列 api_hub 自身有语义的参数</li>
...@@ -44,16 +43,19 @@ public class ApiHubUsageService { ...@@ -44,16 +43,19 @@ public class ApiHubUsageService {
* 组装一个模型的使用方法 * 组装一个模型的使用方法
* *
* @param modelName 对外模型 id * @param modelName 对外模型 id
* @param modelTypes 模型类型(api_hub 的 modalities) * @param inputModalities api_hub 的输入模态
* @param outputModalities api_hub 的输出模态
* @return 使用方法列表,一个端点一条 * @return 使用方法列表,一个端点一条
*/ */
public List<AppModelUsageVO> buildUsageMethods(String modelName, Collection<String> modelTypes) { public List<AppModelUsageVO> buildUsageMethods(String modelName,
List<String> inputModalities,
List<String> outputModalities) {
List<AppModelUsageVO> usageMethods = new ArrayList<>(); List<AppModelUsageVO> usageMethods = new ArrayList<>();
if (modelName == null || modelName.trim().isEmpty()) { if (modelName == null || modelName.trim().isEmpty()) {
return usageMethods; return usageMethods;
} }
String baseUrl = normalizeBase(apiHubProperties.getBaseUrl()); String baseUrl = normalizeBase(apiHubProperties.getBaseUrl());
List<ApiHubEndpoint> endpoints = endpointRegistry.resolveEndpoints(modelTypes); List<ApiHubEndpoint> endpoints = endpointRegistry.resolveEndpoints(inputModalities, outputModalities);
for (ApiHubEndpoint endpoint : endpoints) { for (ApiHubEndpoint endpoint : endpoints) {
usageMethods.add(AppModelUsageVO.builder() usageMethods.add(AppModelUsageVO.builder()
.endpoint(endpoint.getId()) .endpoint(endpoint.getId())
......
...@@ -156,7 +156,7 @@ endpoints: ...@@ -156,7 +156,7 @@ endpoints:
range: auto / reference / edit / extend range: auto / reference / edit / extend
description: 参考素材的任务类型,仅部分模型支持 description: 参考素材的任务类型,仅部分模型支持
audio: audio-speech:
params: params:
- name: model - name: model
type: string type: string
...@@ -174,3 +174,27 @@ endpoints: ...@@ -174,3 +174,27 @@ endpoints:
type: string type: string
required: false required: false
description: 音频格式,如 mp3 / opus / aac / flac / wav / pcm description: 音频格式,如 mp3 / opus / aac / flac / wav / pcm
audio-transcriptions:
params:
- name: file
type: file
required: true
description: 待识别的音频文件,请求体用 multipart/form-data 提交,字段名固定为 file
- name: model
type: string
required: true
description: 模型名称,需与模型市场展示的模型 ID 一致
- name: language
type: string
required: false
description: 识别语种提示,如 zh / en;不给则由模型自动判断
- name: prompt
type: string
required: false
description: 识别提示词,用于引导专有名词与格式
- name: response_format
type: string
required: false
range: text / json
description: 返回格式,取 text 时接口直接返回识别文本,取 json 时返回带 text 字段的 JSON
package com.luhu.computility.module.member.config;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
/**
* New API HTTP 客户端(会员模块专用)
*/
@Slf4j
@Component("memberNewApiClient")
public class MemberNewApiClient {
@Resource
@Qualifier("memberNewApiProperties")
private MemberNewApiProperties newApiProperties;
private static final String HEADER_USER = "New-Api-User";
private static final String HEADER_AUTH = "Authorization";
private static final String CONTENT_TYPE = "application/json";
/**
* 费用换算比例:1元 = 500000 quota
*/
private static final long QUOTA_RATIO = 500000L;
/**
* 将金额转换为 quota
*/
public long convertToQuota(BigDecimal amount) {
return amount.multiply(new BigDecimal(QUOTA_RATIO)).longValue();
}
/**
* 创建兑换码(管理员权限)
*
* @param adminToken 管理员令牌
* @param quota 兑换额度(new api quota)
* @param amount 兑换金额(元)
* @param count 数量
* @param name 名称
* @return 兑换码(返回第一个)
*/
public MemberNewApiResponse<String> createRedemption(String adminToken, Long quota, BigDecimal amount, Integer count, String name) {
String url = newApiProperties.getBaseUrl() + "/api/redemption/";
log.info("[MemberNewApiClient.createRedemption] 请求URL: {}", url);
log.info("[MemberNewApiClient.createRedemption] 请求参数: quota={}, amount={}, count={}, name={}", quota, amount, count, name);
Map<String, Object> body = new HashMap<>();
body.put("quota", quota);
body.put("amount", amount);
body.put("count", count);
body.put("expired_time", 0);
body.put("name", name);
try {
HttpResponse response = HttpRequest.post(url)
.header(HEADER_USER, newApiProperties.getAdminUserId())
.header(HEADER_AUTH, "Bearer " + adminToken)
.body(JSONUtil.toJsonStr(body))
.contentType(CONTENT_TYPE)
.timeout(30000)
.execute();
log.info("[MemberNewApiClient.createRedemption] 响应状态: {}", response.getStatus());
log.info("[MemberNewApiClient.createRedemption] 响应内容: {}", response.body());
// New API 返回 data 是一个数组,需要取出第一个元素
return parseRedemptionCodeResponse(response);
} catch (Exception e) {
log.error("[MemberNewApiClient.createRedemption] 请求异常", e);
return MemberNewApiResponse.<String>builder()
.success(false)
.message("请求异常: " + e.getMessage())
.build();
}
}
/**
* 使用兑换码(用户权限)
*
* @param accessToken 用户访问令牌
* @param userId New API 用户ID
* @param code 兑换码
* @return 兑换后的额度
*/
public MemberNewApiResponse<Long> useRedemption(String accessToken, Integer userId, String code) {
String url = newApiProperties.getBaseUrl() + "/api/user/topup";
log.info("[MemberNewApiClient.useRedemption] 请求URL: {}", url);
log.info("[MemberNewApiClient.useRedemption] 请求参数: userId={}, code={}", userId, code);
Map<String, Object> body = new HashMap<>();
body.put("key", code);
try {
HttpResponse response = HttpRequest.post(url)
.header(HEADER_USER, String.valueOf(userId))
.header(HEADER_AUTH, "Bearer " + accessToken)
.body(JSONUtil.toJsonStr(body))
.contentType(CONTENT_TYPE)
.timeout(30000)
.execute();
log.info("[MemberNewApiClient.useRedemption] 响应状态: {}", response.getStatus());
log.info("[MemberNewApiClient.useRedemption] 响应内容: {}", response.body());
return parseLongResponse(response);
} catch (Exception e) {
log.error("[MemberNewApiClient.useRedemption] 请求异常", e);
return MemberNewApiResponse.<Long>builder()
.success(false)
.message("请求异常: " + e.getMessage())
.build();
}
}
/**
* 获取用户额度
*
* @param accessToken 用户访问令牌
* @param userId New API 用户ID
* @return 用户信息中的 quota
*/
public MemberNewApiResponse<Long> getUserQuota(String accessToken, Integer userId) {
String url = newApiProperties.getBaseUrl() + "/api/user/self";
log.info("[MemberNewApiClient.getUserQuota] 请求URL: {}", url);
log.info("[MemberNewApiClient.getUserQuota] userId={}", userId);
try {
HttpResponse response = HttpRequest.get(url)
.header(HEADER_USER, String.valueOf(userId))
.header(HEADER_AUTH, "Bearer " + accessToken)
.timeout(30000)
.execute();
log.info("[MemberNewApiClient.getUserQuota] 响应状态: {}", response.getStatus());
log.info("[MemberNewApiClient.getUserQuota] 响应内容: {}", response.body());
String body = response.body();
if (StrUtil.isBlank(body)) {
return MemberNewApiResponse.<Long>builder()
.success(false)
.message("Empty response")
.build();
}
JSONObject json = JSONUtil.parseObj(body);
MemberNewApiResponse<Long> result = MemberNewApiResponse.<Long>builder()
.success(json.getBool("success"))
.message(json.getStr("message"))
.build();
if (json.containsKey("data") && !json.isNull("data")) {
JSONObject data = json.getJSONObject("data");
Long quota = data.getLong("quota");
result.setData(quota);
}
return result;
} catch (Exception e) {
log.error("[MemberNewApiClient.getUserQuota] 请求异常", e);
return MemberNewApiResponse.<Long>builder()
.success(false)
.message("请求异常: " + e.getMessage())
.build();
}
}
/**
* 用户登录获取令牌
*
* @param username 用户名
* @param password 密码
* @return 登录响应(包含 accessToken)
*/
public MemberNewApiResponse<Map<String, Object>> login(String username, String password) {
String url = newApiProperties.getBaseUrl() + "/api/user/login";
log.info("[MemberNewApiClient.login] 请求URL: {}", url);
log.info("[MemberNewApiClient.login] 请求参数: username={}", username);
Map<String, Object> body = new HashMap<>();
body.put("username", username);
body.put("password", password);
try {
HttpResponse response = HttpRequest.post(url)
.header(HEADER_USER, newApiProperties.getAdminUserId())
.body(JSONUtil.toJsonStr(body))
.contentType(CONTENT_TYPE)
.timeout(30000)
.execute();
log.info("[MemberNewApiClient.login] 响应状态: {}", response.getStatus());
log.info("[MemberNewApiClient.login] 响应内容: {}", response.body());
return parseMapResponse(response);
} catch (Exception e) {
log.error("[MemberNewApiClient.login] 请求异常", e);
return MemberNewApiResponse.<Map<String, Object>>builder()
.success(false)
.message("请求异常: " + e.getMessage())
.build();
}
}
/**
* 生成访问令牌
*
* @param accessToken 现有访问令牌
* @param userId 用户ID
* @return 新生成的访问令牌
*/
public MemberNewApiResponse<String> generateAccessToken(String accessToken, Integer userId) {
String url = newApiProperties.getBaseUrl() + "/api/user/token";
log.info("[MemberNewApiClient.generateAccessToken] 请求URL: {}", url);
log.info("[MemberNewApiClient.generateAccessToken] userId={}", userId);
try {
HttpResponse response = HttpRequest.get(url)
.header(HEADER_USER, String.valueOf(userId))
.header(HEADER_AUTH, "Bearer " + accessToken)
.timeout(30000)
.execute();
log.info("[MemberNewApiClient.generateAccessToken] 响应状态: {}", response.getStatus());
log.info("[MemberNewApiClient.generateAccessToken] 响应内容: {}", response.body());
return parseResponse(response, String.class);
} catch (Exception e) {
log.error("[MemberNewApiClient.generateAccessToken] 请求异常", e);
return MemberNewApiResponse.<String>builder()
.success(false)
.message("请求异常: " + e.getMessage())
.build();
}
}
/**
* 解析兑换码创建响应(data 是数组,取第一个元素)
*/
private MemberNewApiResponse<String> parseRedemptionCodeResponse(HttpResponse response) {
try {
String body = response.body();
if (StrUtil.isBlank(body)) {
return MemberNewApiResponse.<String>builder()
.success(false)
.message("Empty response")
.build();
}
JSONObject json = JSONUtil.parseObj(body);
MemberNewApiResponse<String> result = MemberNewApiResponse.<String>builder()
.success(json.getBool("success"))
.message(json.getStr("message"))
.build();
if (json.containsKey("data") && !json.isNull("data")) {
Object data = json.get("data");
// data 是一个字符串数组,取第一个
if (data instanceof cn.hutool.json.JSONArray) {
cn.hutool.json.JSONArray arr = (cn.hutool.json.JSONArray) data;
if (!arr.isEmpty()) {
result.setData(arr.getStr(0));
} else {
result.setSuccess(false);
result.setMessage("兑换码列表为空");
}
} else if (data instanceof String) {
result.setData((String) data);
}
}
return result;
} catch (Exception e) {
log.error("[MemberNewApiClient.parseRedemptionCodeResponse] 解析响应异常", e);
return MemberNewApiResponse.<String>builder()
.success(false)
.message("解析响应失败: " + e.getMessage())
.build();
}
}
@SuppressWarnings("unchecked")
private <T> MemberNewApiResponse<T> parseResponse(HttpResponse response, Class<T> dataClass) {
try {
String body = response.body();
if (StrUtil.isBlank(body)) {
return MemberNewApiResponse.<T>builder()
.success(false)
.message("Empty response")
.build();
}
JSONObject json = JSONUtil.parseObj(body);
MemberNewApiResponse<T> result = MemberNewApiResponse.<T>builder()
.success(json.getBool("success"))
.message(json.getStr("message"))
.build();
if (json.containsKey("data") && !json.isNull("data") && dataClass != null) {
Object data = json.get("data");
if (dataClass == String.class) {
if (data instanceof String) {
result.setData((T) data);
} else {
result.setData((T) data.toString());
}
} else if (dataClass == Void.class) {
result.setData(null);
} else if (data instanceof JSONObject) {
result.setData((T) JSONUtil.toBean((JSONObject) data, dataClass));
} else {
result.setData((T) data);
}
}
return result;
} catch (Exception e) {
log.error("[MemberNewApiClient.parseResponse] 解析响应异常", e);
return MemberNewApiResponse.<T>builder()
.success(false)
.message("解析响应失败: " + e.getMessage())
.build();
}
}
private MemberNewApiResponse<Long> parseLongResponse(HttpResponse response) {
try {
String body = response.body();
if (StrUtil.isBlank(body)) {
return MemberNewApiResponse.<Long>builder()
.success(false)
.message("Empty response")
.build();
}
JSONObject json = JSONUtil.parseObj(body);
MemberNewApiResponse<Long> result = MemberNewApiResponse.<Long>builder()
.success(json.getBool("success"))
.message(json.getStr("message"))
.build();
if (json.containsKey("data") && !json.isNull("data")) {
Object data = json.get("data");
if (data instanceof Number) {
result.setData(((Number) data).longValue());
} else {
result.setData(Long.parseLong(data.toString()));
}
}
return result;
} catch (Exception e) {
log.error("[MemberNewApiClient.parseLongResponse] 解析响应异常", e);
return MemberNewApiResponse.<Long>builder()
.success(false)
.message("解析响应失败: " + e.getMessage())
.build();
}
}
@SuppressWarnings("unchecked")
private MemberNewApiResponse<Map<String, Object>> parseMapResponse(HttpResponse response) {
try {
String body = response.body();
if (StrUtil.isBlank(body)) {
return MemberNewApiResponse.<Map<String, Object>>builder()
.success(false)
.message("Empty response")
.build();
}
JSONObject json = JSONUtil.parseObj(body);
MemberNewApiResponse<Map<String, Object>> result = MemberNewApiResponse.<Map<String, Object>>builder()
.success(json.getBool("success"))
.message(json.getStr("message"))
.build();
if (json.containsKey("data") && !json.isNull("data")) {
Object data = json.get("data");
if (data instanceof JSONObject) {
result.setData((Map<String, Object>) data);
} else {
result.setData((Map<String, Object>) JSONUtil.parseObj(data.toString()));
}
}
return result;
} catch (Exception e) {
log.error("[MemberNewApiClient.parseMapResponse] 解析响应异常", e);
return MemberNewApiResponse.<Map<String, Object>>builder()
.success(false)
.message("解析响应失败: " + e.getMessage())
.build();
}
}
}
package com.luhu.computility.module.member.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* New API 配置(会员模块专用)
*/
@Component("memberNewApiProperties")
@ConfigurationProperties(prefix = "computility.new-api")
public class MemberNewApiProperties {
private String baseUrl = "http://localhost:3000";
/**
* 管理员访问令牌
*/
private String adminToken;
/**
* New API 用户ID(管理员)
*/
private String adminUserId = "1";
public String getBaseUrl() {
return baseUrl;
}
public void setBaseUrl(String baseUrl) {
this.baseUrl = baseUrl;
}
public String getAdminToken() {
return adminToken;
}
public void setAdminToken(String adminToken) {
this.adminToken = adminToken;
}
public String getAdminUserId() {
return adminUserId;
}
public void setAdminUserId(String adminUserId) {
this.adminUserId = adminUserId;
}
}
package com.luhu.computility.module.member.config;
import lombok.AllArgsConstructor;
import lombok.experimental.Accessors;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* New API 通用响应(会员模块专用)
*/
@Data
@Accessors(chain = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MemberNewApiResponse<T> {
private Boolean success;
private String message;
private T data;
}
...@@ -71,7 +71,7 @@ public class MemberRechargeWpgjPayController { ...@@ -71,7 +71,7 @@ public class MemberRechargeWpgjPayController {
// 支付成功:更新充值状态为已支付,回调状态为已处理 // 支付成功:更新充值状态为已支付,回调状态为已处理
memberRechargeService.updateRechargeStatus(Long.parseLong(merOrderId), 1, 1); memberRechargeService.updateRechargeStatus(Long.parseLong(merOrderId), 1, 1);
// 3. 执行充值兑换(调用 new API 增加额度) // 3. 执行充值到账(调用 api_hub topup 增加额度,幂等键 recharge:{订单ID})
try { try {
boolean redeemSuccess = memberRechargeService.executeRecharge(Long.parseLong(merOrderId)); boolean redeemSuccess = memberRechargeService.executeRecharge(Long.parseLong(merOrderId));
log.info("[notifyWpgjPay][Member] 充值兑换结果: {}, 商户订单号: {}", redeemSuccess, merOrderId); log.info("[notifyWpgjPay][Member] 充值兑换结果: {}, 商户订单号: {}", redeemSuccess, merOrderId);
......
package com.luhu.computility.module.member.controller.admin.quota;
import com.luhu.computility.framework.apilog.core.annotation.ApiAccessLog;
import com.luhu.computility.framework.common.pojo.CommonResult;
import com.luhu.computility.framework.common.pojo.PageResult;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantGiftReqVO;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantPageReqVO;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantRespVO;
import com.luhu.computility.module.member.service.quota.MemberQuotaGrantService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import static com.luhu.computility.framework.apilog.core.enums.OperateTypeEnum.CREATE;
import static com.luhu.computility.framework.apilog.core.enums.OperateTypeEnum.UPDATE;
import static com.luhu.computility.framework.common.pojo.CommonResult.success;
import static com.luhu.computility.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
/**
* 管理后台 - 额度发放管理
*/
@Tag(name = "管理后台 - 额度发放管理")
@RestController
@RequestMapping("/member/quota-grant")
@RequiredArgsConstructor
@Validated
public class MemberQuotaGrantController {
private final MemberQuotaGrantService quotaGrantService;
@GetMapping("/page")
@Operation(summary = "获取额度发放流水分页")
@PreAuthorize("@ss.hasPermission('member:quota-grant:query')")
public CommonResult<PageResult<MemberQuotaGrantRespVO>> getQuotaGrantPage(@Validated MemberQuotaGrantPageReqVO reqVO) {
return success(quotaGrantService.getQuotaGrantPage(reqVO));
}
@PostMapping("/gift")
@Operation(summary = "赠送额度")
@PreAuthorize("@ss.hasPermission('member:quota-grant:grant')")
@ApiAccessLog(operateType = CREATE)
public CommonResult<Boolean> grantGift(@Valid @RequestBody MemberQuotaGrantGiftReqVO reqVO) {
return success(quotaGrantService.grantGift(reqVO, getLoginUserId()));
}
@PostMapping("/retry")
@Operation(summary = "重试发放失败的额度")
@PreAuthorize("@ss.hasPermission('member:quota-grant:grant')")
@ApiAccessLog(operateType = UPDATE)
public CommonResult<Boolean> retryGrant(@RequestParam("grantId") Long grantId) {
return success(quotaGrantService.retryGrant(grantId, getLoginUserId()));
}
}
package com.luhu.computility.module.member.controller.admin.quota.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.experimental.Accessors;
import javax.validation.constraints.DecimalMin;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.math.BigDecimal;
@Schema(description = "管理后台 - 赠送额度请求 VO")
@Data
@Accessors(chain = true)
public class MemberQuotaGrantGiftReqVO {
@Schema(description = "用户手机号", requiredMode = Schema.RequiredMode.REQUIRED, example = "13800138000")
@NotBlank(message = "用户手机号不能为空")
private String userMobile;
@Schema(description = "赠送额度(元),必须大于 0,不设上限", requiredMode = Schema.RequiredMode.REQUIRED, example = "10.00")
@NotNull(message = "赠送额度不能为空")
@DecimalMin(value = "0.01", message = "赠送额度必须大于 0")
private BigDecimal amount;
@Schema(description = "赠送原因", example = "活动奖励")
@Size(max = 500, message = "赠送原因不能超过 500 个字符")
private String reason;
}
package com.luhu.computility.module.member.controller.admin.quota.vo;
import com.luhu.computility.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.experimental.Accessors;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import java.util.List;
import static com.luhu.computility.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 额度发放流水分页请求 VO")
@Data
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MemberQuotaGrantPageReqVO extends PageParam {
@Schema(description = "用户ID", example = "1")
private Long userId;
@Schema(description = "用户ID列表", example = "[1, 2, 3]")
private List<Long> userIds;
@Schema(description = "用户手机号", example = "13800138000")
private String userMobile;
@Schema(description = "业务类型(1-充值到账,2-赠送发放)", example = "2")
private Integer bizType;
@Schema(description = "发放状态(0-发放失败待重试,1-已发放)", example = "1")
private Integer status;
@Schema(description = "创建时间", example = "[2024-01-01 00:00:00, 2024-12-31 23:59:59]")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}
package com.luhu.computility.module.member.controller.admin.quota.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.experimental.Accessors;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 额度发放流水响应 VO")
@Data
@Accessors(chain = true)
public class MemberQuotaGrantRespVO {
@Schema(description = "主键ID", example = "1")
private Long id;
@Schema(description = "用户ID", example = "1")
private Long userId;
@Schema(description = "用户手机号", example = "13800138000")
private String userMobile;
@Schema(description = "业务类型(1-充值到账,2-赠送发放)", example = "2")
private Integer bizType;
@Schema(description = "业务类型名称")
private String bizTypeName;
@Schema(description = "关联业务ID(充值到账=充值记录ID)", example = "1")
private Long bizId;
@Schema(description = "幂等键", example = "gift:xxx")
private String bizNo;
@Schema(description = "发放额度(元)", example = "10.00")
private BigDecimal amount;
@Schema(description = "发放状态(0-发放失败待重试,1-已发放)", example = "1")
private Integer status;
@Schema(description = "发放状态名称")
private String statusName;
@Schema(description = "发放失败原因")
private String failReason;
@Schema(description = "操作人ID", example = "1")
private Long operatorId;
@Schema(description = "操作人名称")
private String operatorName;
@Schema(description = "赠送原因", example = "活动奖励")
private String reason;
@Schema(description = "传给 api_hub 的备注")
private String apiHubNote;
@Schema(description = "创建时间")
private LocalDateTime createTime;
@Schema(description = "更新时间")
private LocalDateTime updateTime;
}
...@@ -60,7 +60,7 @@ public class MemberRechargeController { ...@@ -60,7 +60,7 @@ public class MemberRechargeController {
@PreAuthorize("@ss.hasPermission('member:recharge:manual')") @PreAuthorize("@ss.hasPermission('member:recharge:manual')")
public CommonResult<Boolean> manualRecharge(@Validated @RequestBody MemberRechargeManualReqVO reqVO) { public CommonResult<Boolean> manualRecharge(@Validated @RequestBody MemberRechargeManualReqVO reqVO) {
Long operatorId = getLoginUserId(); Long operatorId = getLoginUserId();
boolean success = rechargeService.manualRecharge(reqVO.getRechargeId(), operatorId, reqVO.getRedemptionCode()); boolean success = rechargeService.manualRecharge(reqVO.getRechargeId(), operatorId);
return CommonResult.success(success); return CommonResult.success(success);
} }
......
...@@ -3,7 +3,6 @@ package com.luhu.computility.module.member.controller.admin.recharge.vo; ...@@ -3,7 +3,6 @@ package com.luhu.computility.module.member.controller.admin.recharge.vo;
import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data; import lombok.Data;
import lombok.experimental.Accessors; import lombok.experimental.Accessors;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull; import javax.validation.constraints.NotNull;
@Schema(description = "管理后台 - 人工充值请求 VO") @Schema(description = "管理后台 - 人工充值请求 VO")
...@@ -15,8 +14,4 @@ public class MemberRechargeManualReqVO { ...@@ -15,8 +14,4 @@ public class MemberRechargeManualReqVO {
@NotNull(message = "充值记录ID不能为空") @NotNull(message = "充值记录ID不能为空")
private Long rechargeId; private Long rechargeId;
@Schema(description = "人工填写的兑换码", requiredMode = Schema.RequiredMode.REQUIRED, example = "ABC123")
@NotBlank(message = "兑换码不能为空")
private String redemptionCode;
} }
package com.luhu.computility.module.member.dal.dataobject.quota;
import com.baomidou.mybatisplus.annotation.*;
import com.luhu.computility.framework.mybatis.core.dataobject.BaseDO;
import lombok.*;
import lombok.experimental.Accessors;
import java.math.BigDecimal;
/**
* 会员额度发放流水 DO
*
* <p>记录 puhui 侧所有「给 api_hub 用户加额度」的动作:
* <ul>
* <li>bizType=1 充值到账:支付成功回调触发,bizId 关联 member_recharge.id</li>
* <li>bizType=2 赠送发放:运营在管理端手动发放</li>
* </ul>
*
* <p>bizNo 是幂等键(充值=recharge:{订单ID},赠送=gift:{赠号}),数据库上有唯一索引,
* 支付重复回调、人工补发都靠它保证同一笔业务不会重复加额度。
*/
@TableName("member_quota_grant")
@KeySequence("member_quota_grant_seq")
@Data
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MemberQuotaGrantDO extends BaseDO {
/**
* 主键ID
*/
@TableId
private Long id;
/**
* 用户ID
*/
private Long userId;
/**
* 业务类型(1-充值到账,2-赠送发放)
*/
private Integer bizType;
/**
* 关联业务ID(充值到账=member_recharge.id,赠送发放为空)
*/
private Long bizId;
/**
* 幂等键(充值=recharge:{订单ID},赠送=gift:{赠号})
*/
private String bizNo;
/**
* 发放额度(元)
*/
private BigDecimal amount;
/**
* 发放状态(0-未发放成功/失败待重试,1-已发放)
*/
private Integer status;
/**
* 发放失败原因
*/
@TableField(updateStrategy = FieldStrategy.ALWAYS)
private String failReason;
/**
* 操作人ID(赠送发放时记录,充值为空)
*/
private Long operatorId;
/**
* 赠送原因
*/
private String reason;
/**
* 传给 api_hub 的备注(对账用)
*/
private String apiHubNote;
/**
* 业务类型 - 充值到账
*/
public static final int BIZ_TYPE_RECHARGE = 1;
/**
* 业务类型 - 赠送发放
*/
public static final int BIZ_TYPE_GIFT = 2;
/**
* 发放状态 - 未发放成功(失败待重试)
*/
public static final int STATUS_FAILED = 0;
/**
* 发放状态 - 已发放
*/
public static final int STATUS_SUCCESS = 1;
}
...@@ -103,4 +103,12 @@ public class MemberRechargeDO extends BaseDO { ...@@ -103,4 +103,12 @@ public class MemberRechargeDO extends BaseDO {
*/ */
private String agreementPdfUrl; private String agreementPdfUrl;
/**
* 租户编号
*
* <p>表里有 tenant_id 列(由多租户拦截器在插入时自动写入),这里映射出来,
* 供支付回调等「没有租户上下文」的场景取用,避免流水写错租户。
*/
private Long tenantId;
} }
package com.luhu.computility.module.member.dal.mysql.quota;
import com.luhu.computility.framework.common.pojo.PageResult;
import com.luhu.computility.framework.mybatis.core.mapper.BaseMapperX;
import com.luhu.computility.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantPageReqVO;
import com.luhu.computility.module.member.dal.dataobject.quota.MemberQuotaGrantDO;
import org.apache.ibatis.annotations.Mapper;
/**
* 会员额度发放流水 Mapper
*/
@Mapper
public interface MemberQuotaGrantMapper extends BaseMapperX<MemberQuotaGrantDO> {
default MemberQuotaGrantDO selectByBizNo(String bizNo) {
return selectOne(MemberQuotaGrantDO::getBizNo, bizNo);
}
default PageResult<MemberQuotaGrantDO> selectPage(MemberQuotaGrantPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<MemberQuotaGrantDO>()
.eqIfPresent(MemberQuotaGrantDO::getUserId, reqVO.getUserId())
.inIfPresent(MemberQuotaGrantDO::getUserId, reqVO.getUserIds())
.eqIfPresent(MemberQuotaGrantDO::getBizType, reqVO.getBizType())
.eqIfPresent(MemberQuotaGrantDO::getStatus, reqVO.getStatus())
.betweenIfPresent(MemberQuotaGrantDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(MemberQuotaGrantDO::getId));
}
}
...@@ -56,4 +56,14 @@ public interface ErrorCodeConstants { ...@@ -56,4 +56,14 @@ public interface ErrorCodeConstants {
ErrorCode GROUP_HAS_USER = new ErrorCode(1_004_012_001, "用户分组下存在用户,无法删除"); ErrorCode GROUP_HAS_USER = new ErrorCode(1_004_012_001, "用户分组下存在用户,无法删除");
ErrorCode ENTERPRISE_NOT_EXISTS = new ErrorCode(1_004_012_002, "客户企业不存在"); ErrorCode ENTERPRISE_NOT_EXISTS = new ErrorCode(1_004_012_002, "客户企业不存在");
ErrorCode RESOURCE_NOT_EXISTS = new ErrorCode(1_004_012_003, "用户资源不存在"); ErrorCode RESOURCE_NOT_EXISTS = new ErrorCode(1_004_012_003, "用户资源不存在");
//========== 额度发放 1-004-013-000 ==========
ErrorCode QUOTA_GRANT_NOT_EXISTS = new ErrorCode(1_004_013_000, "额度发放流水不存在");
ErrorCode QUOTA_GRANT_AMOUNT_INVALID = new ErrorCode(1_004_013_001, "发放额度必须大于 0");
ErrorCode QUOTA_GRANT_USER_NOT_EXISTS = new ErrorCode(1_004_013_002, "用户不存在: {}");
//========== 充值到账 / 额度发放 1-004-014-000 ==========
ErrorCode RECHARGE_MANUAL_FAILED = new ErrorCode(1_004_014_000, "人工充值失败: {}");
ErrorCode QUOTA_GRANT_GIFT_FAILED = new ErrorCode(1_004_014_001, "额度发放失败: {}");
ErrorCode QUOTA_GRANT_RETRY_FAILED = new ErrorCode(1_004_014_002, "额度发放重试失败: {}");
} }
package com.luhu.computility.module.member.service.quota;
import com.luhu.computility.framework.common.pojo.PageResult;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantGiftReqVO;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantPageReqVO;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantRespVO;
import com.luhu.computility.module.member.dal.dataobject.quota.MemberQuotaGrantDO;
import com.luhu.computility.module.member.dal.dataobject.recharge.MemberRechargeDO;
/**
* 会员额度发放流水 Service
*
* <p>puhui 侧所有「给 api_hub 用户加额度」的动作都走这里,每笔动作在
* {@code member_quota_grant} 留一条流水:发放成功 status=1,失败 status=0 并记失败原因,
* 失败的在管理端列表点行内「重试」按钮重新发起。
*/
public interface MemberQuotaGrantService {
/**
* 分页查询额度发放流水(后台管理)
*/
PageResult<MemberQuotaGrantRespVO> getQuotaGrantPage(MemberQuotaGrantPageReqVO reqVO);
/**
* 管理员给会员赠送额度
*
* @param reqVO 赠送请求(手机号 + 金额 + 原因)
* @param operatorId 操作人ID
* @return 发放是否成功
*/
Boolean grantGift(MemberQuotaGrantGiftReqVO reqVO, Long operatorId);
/**
* 重试发放失败的额度
*
* @param grantId 发放流水ID
* @param operatorId 操作人ID
* @return 发放是否成功
*/
Boolean retryGrant(Long grantId, Long operatorId);
/**
* 充值到账发放(支付成功回调触发)
*
* <p>幂等键为 {@code recharge:{充值记录ID}},重复回调不会重复加额度。
*
* @param recharge 充值记录
* @return 发放是否成功
*/
Boolean grantForRecharge(MemberRechargeDO recharge);
/**
* 按幂等键查询发放流水
*/
MemberQuotaGrantDO getGrantByBizNo(String bizNo);
}
package com.luhu.computility.module.member.service.quota;
import com.luhu.computility.framework.common.pojo.PageResult;
import com.luhu.computility.framework.tenant.core.util.TenantUtils;
import com.luhu.computility.module.apihub.api.apihub.ApiHubUserApi;
import com.luhu.computility.module.apihub.api.apihub.dto.ApiHubTopUpResultDTO;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantGiftReqVO;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantPageReqVO;
import com.luhu.computility.module.member.controller.admin.quota.vo.MemberQuotaGrantRespVO;
import com.luhu.computility.module.member.dal.dataobject.quota.MemberQuotaGrantDO;
import com.luhu.computility.module.member.dal.dataobject.recharge.MemberRechargeDO;
import com.luhu.computility.module.member.dal.dataobject.user.MemberUserDO;
import com.luhu.computility.module.member.dal.mysql.quota.MemberQuotaGrantMapper;
import com.luhu.computility.module.member.service.user.MemberUserService;
import com.luhu.computility.module.system.api.user.AdminUserApi;
import com.luhu.computility.module.system.api.user.dto.AdminUserRespDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
import static com.luhu.computility.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.luhu.computility.module.member.enums.ErrorCodeConstants.QUOTA_GRANT_AMOUNT_INVALID;
import static com.luhu.computility.module.member.enums.ErrorCodeConstants.QUOTA_GRANT_GIFT_FAILED;
import static com.luhu.computility.module.member.enums.ErrorCodeConstants.QUOTA_GRANT_NOT_EXISTS;
import static com.luhu.computility.module.member.enums.ErrorCodeConstants.QUOTA_GRANT_RETRY_FAILED;
import static com.luhu.computility.module.member.enums.ErrorCodeConstants.QUOTA_GRANT_USER_NOT_EXISTS;
/**
* 会员额度发放流水 Service 实现
*
* <p>所有对 api_hub 额度的写入都收敛到这里,每笔都先落一条 {@code member_quota_grant} 流水:
* <ul>
* <li>幂等键 {@code bizNo} 上有唯一索引,支付重复回调、人工重发都靠它挡住重复加额度</li>
* <li>发放失败时把流水置为 status=0 并记录失败原因(失败台账保留,供重试),
* 同时抛出业务异常,避免前端把失败当成成功</li>
* </ul>
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class MemberQuotaGrantServiceImpl implements MemberQuotaGrantService {
private final MemberQuotaGrantMapper quotaGrantMapper;
private final MemberUserService memberUserService;
private final ApiHubUserApi apiHubUserApi;
private final AdminUserApi adminUserApi;
private static final Map<Integer, String> BIZ_TYPE_NAMES = Map.of(
MemberQuotaGrantDO.BIZ_TYPE_RECHARGE, "充值到账",
MemberQuotaGrantDO.BIZ_TYPE_GIFT, "赠送发放"
);
private static final Map<Integer, String> STATUS_NAMES = Map.of(
MemberQuotaGrantDO.STATUS_FAILED, "发放失败",
MemberQuotaGrantDO.STATUS_SUCCESS, "已发放"
);
@Override
public PageResult<MemberQuotaGrantRespVO> getQuotaGrantPage(MemberQuotaGrantPageReqVO reqVO) {
// 手机号模糊匹配 → 用户ID列表
List<Long> userIds = null;
if (reqVO.getUserMobile() != null && !reqVO.getUserMobile().isEmpty()) {
List<MemberUserDO> users = memberUserService.getUserListByMobileLike(reqVO.getUserMobile());
if (users.isEmpty()) {
return new PageResult<>(java.util.Collections.emptyList(), 0L);
}
userIds = users.stream().map(MemberUserDO::getId).collect(Collectors.toList());
}
MemberQuotaGrantPageReqVO queryVO = new MemberQuotaGrantPageReqVO();
queryVO.setPageNo(reqVO.getPageNo());
queryVO.setPageSize(reqVO.getPageSize());
queryVO.setUserId(reqVO.getUserId());
queryVO.setUserIds(userIds);
queryVO.setBizType(reqVO.getBizType());
queryVO.setStatus(reqVO.getStatus());
queryVO.setCreateTime(reqVO.getCreateTime());
PageResult<MemberQuotaGrantDO> pageResult = quotaGrantMapper.selectPage(queryVO);
Map<Long, MemberUserDO> userMap = loadUserMap(pageResult.getList().stream()
.map(MemberQuotaGrantDO::getUserId).collect(Collectors.toList()));
Map<Long, AdminUserRespDTO> adminUserMap = loadAdminUserMap(pageResult.getList().stream()
.map(MemberQuotaGrantDO::getOperatorId).collect(Collectors.toList()));
List<MemberQuotaGrantRespVO> voList = pageResult.getList().stream()
.map(grant -> convertToRespVO(grant, userMap.get(grant.getUserId()),
adminUserMap.get(grant.getOperatorId())))
.collect(Collectors.toList());
return new PageResult<>(voList, pageResult.getTotal());
}
@Override
public Boolean grantGift(MemberQuotaGrantGiftReqVO reqVO, Long operatorId) {
if (reqVO.getAmount() == null || reqVO.getAmount().compareTo(BigDecimal.ZERO) <= 0) {
throw exception(QUOTA_GRANT_AMOUNT_INVALID);
}
MemberUserDO user = memberUserService.getUserByMobile(reqVO.getUserMobile());
if (user == null) {
throw exception(QUOTA_GRANT_USER_NOT_EXISTS, reqVO.getUserMobile());
}
String bizNo = "gift:" + UUID.randomUUID().toString().replace("-", "");
String note = buildGiftNote(reqVO.getReason());
MemberQuotaGrantDO grant = MemberQuotaGrantDO.builder()
.userId(user.getId())
.bizType(MemberQuotaGrantDO.BIZ_TYPE_GIFT)
.bizNo(bizNo)
.amount(reqVO.getAmount())
.status(MemberQuotaGrantDO.STATUS_FAILED)
.operatorId(operatorId)
.reason(reqVO.getReason())
.apiHubNote(note)
.build();
quotaGrantMapper.insert(grant);
log.info("[额度发放] 赠送流水已创建, grantId={}, userId={}, amount={}, operatorId={}",
grant.getId(), user.getId(), reqVO.getAmount(), operatorId);
if (!Boolean.TRUE.equals(doGrant(grant, user))) {
// 失败台账要留下来供重试,所以这里不能被事务回滚;改为抛业务异常,让前端明确感知失败
throw exception(QUOTA_GRANT_GIFT_FAILED, grant.getFailReason());
}
return true;
}
@Override
public Boolean retryGrant(Long grantId, Long operatorId) {
MemberQuotaGrantDO grant = quotaGrantMapper.selectById(grantId);
if (grant == null) {
throw exception(QUOTA_GRANT_NOT_EXISTS);
}
if (MemberQuotaGrantDO.STATUS_SUCCESS == (grant.getStatus() != null ? grant.getStatus() : -1)) {
// 已发放成功,无需重试
return true;
}
MemberUserDO user = memberUserService.getUser(grant.getUserId());
if (user == null) {
markFailed(grant, "用户不存在");
throw exception(QUOTA_GRANT_RETRY_FAILED, "用户不存在");
}
log.info("[额度发放] 重试发放, grantId={}, bizNo={}, amount={}, operatorId={}",
grantId, grant.getBizNo(), grant.getAmount(), operatorId);
if (!Boolean.TRUE.equals(doGrant(grant, user))) {
throw exception(QUOTA_GRANT_RETRY_FAILED, grant.getFailReason());
}
return true;
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean grantForRecharge(MemberRechargeDO recharge) {
Long tenantId = recharge.getTenantId();
if (tenantId == null) {
// 充值记录上没有租户信息,按当前上下文处理
return doGrantForRecharge(recharge);
}
// 支付回调没有租户上下文(回调 URL 在 computility.tenant.ignore-urls 中),
// 这里显式切到充值记录所属租户,保证流水的 tenant_id 与充值记录一致,
// 管理端才能查到该流水并复用它重试,不会撞 uk_biz_no 唯一索引
return TenantUtils.execute(tenantId, () -> doGrantForRecharge(recharge));
}
/**
* 执行充值到账的额度发放(调用方需保证租户上下文正确)
*/
private Boolean doGrantForRecharge(MemberRechargeDO recharge) {
String bizNo = "recharge:" + recharge.getId();
MemberQuotaGrantDO grant = quotaGrantMapper.selectByBizNo(bizNo);
if (grant != null && MemberQuotaGrantDO.STATUS_SUCCESS == (grant.getStatus() != null ? grant.getStatus() : -1)) {
// 已发放过,支付重复回调直接跳过
log.info("[额度发放] 充值到账已发放过,跳过, rechargeId={}", recharge.getId());
return true;
}
MemberUserDO user = memberUserService.getUser(recharge.getUserId());
if (user == null) {
throw exception(QUOTA_GRANT_USER_NOT_EXISTS, recharge.getUserId());
}
if (grant == null) {
String note = "充值到账-" + recharge.getId();
grant = MemberQuotaGrantDO.builder()
.userId(recharge.getUserId())
.bizType(MemberQuotaGrantDO.BIZ_TYPE_RECHARGE)
.bizId(recharge.getId())
.bizNo(bizNo)
.amount(recharge.getAmount())
.status(MemberQuotaGrantDO.STATUS_FAILED)
.apiHubNote(note)
.build();
quotaGrantMapper.insert(grant);
} else {
// 之前发放失败过,重新按最新金额发起
grant.setAmount(recharge.getAmount());
}
return doGrant(grant, user);
}
@Override
public MemberQuotaGrantDO getGrantByBizNo(String bizNo) {
return quotaGrantMapper.selectByBizNo(bizNo);
}
/**
* 执行发放:调 api_hub topup,成功置 status=1,失败置 status=0 并记失败原因
*/
private Boolean doGrant(MemberQuotaGrantDO grant, MemberUserDO user) {
ApiHubTopUpResultDTO result = apiHubUserApi.topUp(user.getApiHubUserId(), grant.getAmount(),
grant.getApiHubNote());
if (!Boolean.TRUE.equals(result.getSuccess())) {
markFailed(grant, result.getMessage());
return false;
}
MemberQuotaGrantDO updateDO = MemberQuotaGrantDO.builder().build();
updateDO.setId(grant.getId());
updateDO.setStatus(MemberQuotaGrantDO.STATUS_SUCCESS);
updateDO.setFailReason(null);
quotaGrantMapper.updateById(updateDO);
grant.setStatus(MemberQuotaGrantDO.STATUS_SUCCESS);
log.info("[额度发放] 发放成功, grantId={}, userId={}, amount={}, 余额={}",
grant.getId(), grant.getUserId(), grant.getAmount(), result.getBalanceYuan());
return true;
}
/**
* 标记发放失败并记录原因
*/
private void markFailed(MemberQuotaGrantDO grant, String reason) {
String failReason = reason != null && !reason.isEmpty() ? reason : "api_hub 充值失败";
if (failReason.length() > 500) {
failReason = failReason.substring(0, 500);
}
MemberQuotaGrantDO updateDO = MemberQuotaGrantDO.builder().build();
updateDO.setId(grant.getId());
updateDO.setStatus(MemberQuotaGrantDO.STATUS_FAILED);
updateDO.setFailReason(failReason);
quotaGrantMapper.updateById(updateDO);
grant.setStatus(MemberQuotaGrantDO.STATUS_FAILED);
grant.setFailReason(failReason);
log.warn("[额度发放] 发放失败, grantId={}, userId={}, amount={}, reason={}",
grant.getId(), grant.getUserId(), grant.getAmount(), failReason);
}
/**
* 构造赠送备注:api_hub 侧最多保留 200 字符,DB 字段 api_hub_note 也是 200 长度
*/
private String buildGiftNote(String reason) {
String note = (reason != null && !reason.isEmpty()) ? reason : "管理员赠送";
String full = "赠送-" + note;
return full.length() > 200 ? full.substring(0, 200) : full;
}
private Map<Long, MemberUserDO> loadUserMap(List<Long> userIds) {
Map<Long, MemberUserDO> userMap = new HashMap<>();
List<Long> ids = userIds.stream().filter(java.util.Objects::nonNull).distinct().collect(Collectors.toList());
if (ids.isEmpty()) {
return userMap;
}
for (MemberUserDO user : memberUserService.getUserList(ids)) {
if (user != null) {
userMap.put(user.getId(), user);
}
}
return userMap;
}
private Map<Long, AdminUserRespDTO> loadAdminUserMap(List<Long> adminUserIds) {
Map<Long, AdminUserRespDTO> adminUserMap = new HashMap<>();
List<Long> ids = adminUserIds.stream().filter(java.util.Objects::nonNull).distinct().collect(Collectors.toList());
if (ids.isEmpty()) {
return adminUserMap;
}
for (AdminUserRespDTO adminUser : adminUserApi.getUserList(ids)) {
if (adminUser != null) {
adminUserMap.put(adminUser.getId(), adminUser);
}
}
return adminUserMap;
}
private MemberQuotaGrantRespVO convertToRespVO(MemberQuotaGrantDO grant, MemberUserDO user,
AdminUserRespDTO adminUser) {
MemberQuotaGrantRespVO vo = new MemberQuotaGrantRespVO();
vo.setId(grant.getId());
vo.setUserId(grant.getUserId());
vo.setUserMobile(user != null ? user.getMobile() : null);
vo.setBizType(grant.getBizType());
vo.setBizTypeName(BIZ_TYPE_NAMES.getOrDefault(grant.getBizType(), "未知"));
vo.setBizId(grant.getBizId());
vo.setBizNo(grant.getBizNo());
vo.setAmount(grant.getAmount());
vo.setStatus(grant.getStatus());
vo.setStatusName(STATUS_NAMES.getOrDefault(grant.getStatus(), "未知"));
vo.setFailReason(grant.getFailReason());
vo.setOperatorId(grant.getOperatorId());
vo.setOperatorName(adminUser != null ? adminUser.getNickname() : null);
vo.setReason(grant.getReason());
vo.setApiHubNote(grant.getApiHubNote());
vo.setCreateTime(grant.getCreateTime());
vo.setUpdateTime(grant.getUpdateTime());
return vo;
}
}
...@@ -57,19 +57,18 @@ public interface MemberRechargeService { ...@@ -57,19 +57,18 @@ public interface MemberRechargeService {
PageResult<MemberRechargeRespVO> getPendingRechargePage(PageParam pageParam); PageResult<MemberRechargeRespVO> getPendingRechargePage(PageParam pageParam);
/** /**
* 执行充值兑换(支付成功后调用) * 执行充值到账(支付成功后调用)
* @return 是否兑换成功 * @return 是否到账成功
*/ */
boolean executeRecharge(Long rechargeId); boolean executeRecharge(Long rechargeId);
/** /**
* 人工充值处理 * 人工充值处理:重新发起一次额度到账
* @param rechargeId 充值记录ID * @param rechargeId 充值记录ID
* @param operatorId 操作人ID * @param operatorId 操作人ID
* @param redemptionCode 人工填写的兑换码
* @return 是否成功 * @return 是否成功
*/ */
boolean manualRecharge(Long rechargeId, Long operatorId, String redemptionCode); boolean manualRecharge(Long rechargeId, Long operatorId);
/** /**
* 获取待充值数量 * 获取待充值数量
......
...@@ -2,16 +2,15 @@ package com.luhu.computility.module.member.service.recharge; ...@@ -2,16 +2,15 @@ package com.luhu.computility.module.member.service.recharge;
import com.luhu.computility.framework.common.pojo.PageParam; import com.luhu.computility.framework.common.pojo.PageParam;
import com.luhu.computility.framework.common.pojo.PageResult; import com.luhu.computility.framework.common.pojo.PageResult;
import com.luhu.computility.module.member.config.MemberNewApiClient;
import com.luhu.computility.module.member.config.MemberNewApiProperties;
import com.luhu.computility.module.member.config.MemberNewApiResponse;
import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargeExcelVO; import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargeExcelVO;
import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargeExportReqVO; import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargeExportReqVO;
import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargePageReqVO; import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargePageReqVO;
import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargeRespVO; import com.luhu.computility.module.member.controller.admin.recharge.vo.MemberRechargeRespVO;
import com.luhu.computility.module.member.dal.dataobject.quota.MemberQuotaGrantDO;
import com.luhu.computility.module.member.dal.dataobject.recharge.MemberRechargeDO; import com.luhu.computility.module.member.dal.dataobject.recharge.MemberRechargeDO;
import com.luhu.computility.module.member.dal.dataobject.user.MemberUserDO; import com.luhu.computility.module.member.dal.dataobject.user.MemberUserDO;
import com.luhu.computility.module.member.dal.mysql.recharge.MemberRechargeMapper; import com.luhu.computility.module.member.dal.mysql.recharge.MemberRechargeMapper;
import com.luhu.computility.module.member.service.quota.MemberQuotaGrantService;
import com.luhu.computility.module.member.service.user.MemberUserService; import com.luhu.computility.module.member.service.user.MemberUserService;
import com.luhu.computility.module.system.api.user.AdminUserApi; import com.luhu.computility.module.system.api.user.AdminUserApi;
import com.luhu.computility.module.system.api.user.dto.AdminUserRespDTO; import com.luhu.computility.module.system.api.user.dto.AdminUserRespDTO;
...@@ -27,6 +26,9 @@ import java.util.List; ...@@ -27,6 +26,9 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import static com.luhu.computility.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.luhu.computility.module.member.enums.ErrorCodeConstants.RECHARGE_MANUAL_FAILED;
@Slf4j @Slf4j
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
...@@ -34,8 +36,7 @@ public class MemberRechargeServiceImpl implements MemberRechargeService { ...@@ -34,8 +36,7 @@ public class MemberRechargeServiceImpl implements MemberRechargeService {
private final MemberRechargeMapper rechargeMapper; private final MemberRechargeMapper rechargeMapper;
private final MemberUserService memberUserService; private final MemberUserService memberUserService;
private final MemberNewApiClient memberNewApiClient; private final MemberQuotaGrantService quotaGrantService;
private final MemberNewApiProperties newApiProperties;
private final AdminUserApi adminUserApi; private final AdminUserApi adminUserApi;
private static final Map<String, String> PAY_CHANNEL_NAMES = Map.of( private static final Map<String, String> PAY_CHANNEL_NAMES = Map.of(
...@@ -237,16 +238,16 @@ public class MemberRechargeServiceImpl implements MemberRechargeService { ...@@ -237,16 +238,16 @@ public class MemberRechargeServiceImpl implements MemberRechargeService {
} }
/** /**
* 执行充值兑换 * 执行充值到账
* 流程:支付成功后调用 *
* 1. 用管理员权限创建兑换码 * <p>流程:支付成功后调用,走 api_hub 管理端 topup 接口直接给用户加额度,
* 2. 用用户权限使用兑换码 * 幂等键为 {@code recharge:{充值记录ID}},支付重复回调不会重复加额度。
* *
* @param rechargeId 充值记录ID * @param rechargeId 充值记录ID
* @return 是否兑换成功 * @return 是否到账成功
*/ */
public boolean executeRecharge(Long rechargeId) { public boolean executeRecharge(Long rechargeId) {
log.info("[executeRecharge] 开始执行充值兑换,rechargeId={}", rechargeId); log.info("[executeRecharge] 开始执行充值到账,rechargeId={}", rechargeId);
// 1. 获取充值记录 // 1. 获取充值记录
MemberRechargeDO recharge = rechargeMapper.selectById(rechargeId); MemberRechargeDO recharge = rechargeMapper.selectById(rechargeId);
...@@ -255,137 +256,122 @@ public class MemberRechargeServiceImpl implements MemberRechargeService { ...@@ -255,137 +256,122 @@ public class MemberRechargeServiceImpl implements MemberRechargeService {
return false; return false;
} }
// 2. 检查是否已兑换 // 2. 检查是否已到账
if (recharge.getRedeemed() != null && recharge.getRedeemed() == 1) { if (recharge.getRedeemed() != null && recharge.getRedeemed() == 1) {
log.warn("[executeRecharge] 该充值记录已兑换过,rechargeId={}", rechargeId); log.warn("[executeRecharge] 该充值记录已到账过,rechargeId={}", rechargeId);
return true; return true;
} }
// 3. 获取用户信息 // 3. 发放额度(失败信息落在 member_quota_grant,可在赠送管理里重试)
MemberUserDO user = memberUserService.getUser(recharge.getUserId()); boolean success;
if (user == null) { String failRemark;
log.error("[executeRecharge] 用户不存在,userId={}", recharge.getUserId()); try {
updateRedeemedStatus(rechargeId, 2, "用户不存在"); success = Boolean.TRUE.equals(quotaGrantService.grantForRecharge(recharge));
return false; } catch (Exception e) {
} log.error("[executeRecharge] 充值到账异常,rechargeId={}", rechargeId, e);
success = false;
// 4. 检查用户是否有 new api 信息 failRemark = "充值到账异常: " + e.getMessage();
if (user.getNewapiAccessToken() == null || user.getNewapiUserId() == null) {
log.error("[executeRecharge] 用户未绑定new api账号,userId={}", recharge.getUserId());
updateRedeemedStatus(rechargeId, 2, "用户未绑定new api账号");
return false;
}
// 5. 转换额度:金额 -> quota
long quota = memberNewApiClient.convertToQuota(recharge.getAmount());
log.info("[executeRecharge] 转换额度:amount={} -> quota={}", recharge.getAmount(), quota);
// 6. 用管理员权限创建兑换码
String adminToken = newApiProperties.getAdminToken();
MemberNewApiResponse<String> createResp = memberNewApiClient.createRedemption(
adminToken, quota, recharge.getAmount(), 1, "充值-" + rechargeId);
if (createResp.getSuccess() == null || !createResp.getSuccess()) {
log.error("[executeRecharge] 创建兑换码失败:{}", createResp.getMessage());
updateRedeemedStatus(rechargeId, 2, "创建兑换码失败: " + createResp.getMessage());
return false;
} }
if (success) {
// 7. 解析兑换码 updateRedeemedStatus(rechargeId, 1, "充值到账成功");
String redemptionCode = createResp.getData(); log.info("[executeRecharge] 充值到账完成,rechargeId={}", rechargeId);
if (redemptionCode == null || redemptionCode.isEmpty()) { return true;
log.error("[executeRecharge] 兑换码为空");
updateRedeemedStatus(rechargeId, 2, "兑换码为空");
return false;
} }
log.info("[executeRecharge] 创建兑换码成功,code={}", redemptionCode); // 4. 失败:置为待充值(2),由管理端在赠送管理里重试
MemberQuotaGrantDO grant = quotaGrantService.getGrantByBizNo("recharge:" + rechargeId);
// 8. 用用户权限使用兑换码 failRemark = "充值到账失败" + (grant != null && grant.getFailReason() != null
String userAccessToken = user.getNewapiAccessToken(); ? ": " + grant.getFailReason() : "");
Integer newapiUserId = Integer.parseInt(user.getNewapiUserId().toString()); updateRedeemedStatus(rechargeId, 2, failRemark);
log.error("[executeRecharge] 充值到账失败,rechargeId={}, reason={}", rechargeId, failRemark);
MemberNewApiResponse<Long> useResp = memberNewApiClient.useRedemption(userAccessToken, newapiUserId, redemptionCode);
if (useResp.getSuccess() == null || !useResp.getSuccess()) {
log.error("[executeRecharge] 使用兑换码失败:{}", useResp.getMessage());
// 保存兑换码和失败状态
updateRedeemedWithCode(rechargeId, 2, redemptionCode, quota, "使用兑换码失败: " + useResp.getMessage() + ";兑换码:" + redemptionCode);
return false; return false;
} }
log.info("[executeRecharge] 使用兑换码成功,增加额度:{}", useResp.getData());
// 9. 更新兑换状态
updateRedeemedWithCode(rechargeId, 1, redemptionCode, quota, "兑换成功;兑换码:" + redemptionCode);
log.info("[executeRecharge] 充值兑换完成,rechargeId={}, quota={}", rechargeId, quota);
return true;
}
/** /**
* 更新兑换状态(不包含兑换码) * 更新兑换状态
*/ */
private void updateRedeemedStatus(Long id, Integer redeemed, String remark) { private void updateRedeemedStatus(Long id, Integer redeemed, String remark) {
MemberRechargeDO updateDO = MemberRechargeDO.builder().build(); MemberRechargeDO updateDO = MemberRechargeDO.builder().build();
updateDO.setId(id); updateDO.setId(id);
updateDO.setRedeemed(redeemed); updateDO.setRedeemed(redeemed);
if (remark != null) { if (remark != null) {
updateDO.setRemark(remark); updateDO.setRemark(limitRemark(remark));
} }
rechargeMapper.updateById(updateDO); rechargeMapper.updateById(updateDO);
} }
/** /**
* 更新兑换状态(包含兑换码) * 备注字段最长 255 字符,失败原因拼上前缀后可能超长,这里做截断
*/ */
private void updateRedeemedWithCode(Long id, Integer redeemed, String code, Long quota, String remark) { private static String limitRemark(String remark) {
MemberRechargeDO updateDO = MemberRechargeDO.builder().build(); if (remark == null) {
updateDO.setId(id); return null;
updateDO.setRedeemed(redeemed);
updateDO.setRedemptionCode(code);
updateDO.setRedemptionQuota(quota);
if (remark != null) {
updateDO.setRemark(remark);
} }
rechargeMapper.updateById(updateDO); return remark.length() > 255 ? remark.substring(0, 255) : remark;
} }
/** /**
* 人工充值处理 * 人工充值处理
*
* <p>api_hub 没有兑换码,人工充值即「重新发起一次 toap 到账」:
* 复用充值记录对应的幂等键 {@code recharge:{充值记录ID}},已发放过的不会重复加额度。
*
* @param rechargeId 充值记录ID * @param rechargeId 充值记录ID
* @param operatorId 操作人ID * @param operatorId 操作人ID
* @param redemptionCode 人工填写的兑换码 * @return 固定返回 true;失败时抛出业务异常,避免前端把失败当成成功
* @return 是否成功
*/ */
public boolean manualRecharge(Long rechargeId, Long operatorId, String redemptionCode) { public boolean manualRecharge(Long rechargeId, Long operatorId) {
log.info("[manualRecharge] 开始人工充值,rechargeId={}, operatorId={}, code={}", rechargeId, operatorId, redemptionCode); log.info("[manualRecharge] 开始人工充值,rechargeId={}, operatorId={}", rechargeId, operatorId);
// 1. 获取充值记录 // 1. 获取充值记录
MemberRechargeDO recharge = rechargeMapper.selectById(rechargeId); MemberRechargeDO recharge = rechargeMapper.selectById(rechargeId);
if (recharge == null) { if (recharge == null) {
log.error("[manualRecharge] 充值记录不存在,rechargeId={}", rechargeId); log.error("[manualRecharge] 充值记录不存在,rechargeId={}", rechargeId);
return false; throw exception(RECHARGE_MANUAL_FAILED, "充值记录不存在");
} }
// 2. 检查状态是否为待充值(2) // 2. 检查状态是否为待充值(2)
if (recharge.getRedeemed() == null || recharge.getRedeemed() != 2) { if (recharge.getRedeemed() == null || recharge.getRedeemed() != 2) {
log.error("[manualRecharge] 该充值记录不是待充值状态,rechargeId={}, redeemed={}", rechargeId, recharge.getRedeemed()); log.error("[manualRecharge] 该充值记录不是待充值状态,rechargeId={}, redeemed={}", rechargeId, recharge.getRedeemed());
return false; throw exception(RECHARGE_MANUAL_FAILED, "该充值记录不是待充值状态");
}
// 3. 重新发起额度发放
boolean success;
String failReason = null;
try {
success = Boolean.TRUE.equals(quotaGrantService.grantForRecharge(recharge));
} catch (Exception e) {
log.error("[manualRecharge] 人工充值异常,rechargeId={}", rechargeId, e);
success = false;
failReason = e.getMessage();
}
if (!success) {
if (failReason == null) {
MemberQuotaGrantDO grant = quotaGrantService.getGrantByBizNo("recharge:" + rechargeId);
failReason = grant != null ? grant.getFailReason() : null;
}
String failRemark = "人工充值失败" + (failReason != null ? ": " + failReason : "");
// 状态仍为待充值(2),以便下次重试;但保留本次人工充值的操作痕迹
MemberRechargeDO failDO = MemberRechargeDO.builder().build();
failDO.setId(rechargeId);
failDO.setRedeemed(2);
failDO.setRemark(limitRemark(failRemark));
failDO.setManualOperatorId(operatorId);
failDO.setManualProcessTime(LocalDateTime.now());
rechargeMapper.updateById(failDO);
log.error("[manualRecharge] 人工充值失败,rechargeId={}, reason={}", rechargeId, failRemark);
// 失败必须让前端感知到,不能返回「成功」
throw exception(RECHARGE_MANUAL_FAILED, failReason != null ? failReason : "未知原因");
} }
// 3. 构建新的备注
String oldRemark = recharge.getRemark() != null ? recharge.getRemark() : "";
String newRemark = oldRemark + ";已人工处理,兑换码:" + redemptionCode;
// 4. 更新记录 // 4. 更新记录
MemberRechargeDO updateDO = MemberRechargeDO.builder().build(); MemberRechargeDO updateDO = MemberRechargeDO.builder().build();
updateDO.setId(rechargeId); updateDO.setId(rechargeId);
updateDO.setRedeemed(3); // 已人工充值 updateDO.setRedeemed(3); // 已人工充值
updateDO.setRedemptionCode(redemptionCode);
updateDO.setManualOperatorId(operatorId); updateDO.setManualOperatorId(operatorId);
updateDO.setManualProcessTime(LocalDateTime.now()); updateDO.setManualProcessTime(LocalDateTime.now());
updateDO.setRemark(newRemark); updateDO.setRemark("已人工充值");
rechargeMapper.updateById(updateDO); rechargeMapper.updateById(updateDO);
log.info("[manualRecharge] 人工充值完成,rechargeId={}", rechargeId); log.info("[manualRecharge] 人工充值完成,rechargeId={}", rechargeId);
......
-- ============== 会员额度发放流水表 ==============
-- 记录 puhui 侧所有「给 api_hub 用户加额度」的动作:
-- biz_type=1 充值到账:支付成功回调触发,关联 member_recharge.id
-- biz_type=2 赠送发放:运营在管理端手动发放
-- 发放失败(status=0)保留失败原因,供人工补偿重试;
-- biz_no 唯一索引保证同一笔业务不会重复发放额度(支付重复回调、人工补发都靠它兜底)。
CREATE TABLE IF NOT EXISTS `member_quota_grant`
(
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`user_id` bigint NOT NULL COMMENT '用户ID',
`biz_type` tinyint NOT NULL COMMENT '业务类型(1-充值到账,2-赠送发放)',
`biz_id` bigint DEFAULT NULL COMMENT '关联业务ID(充值到账=member_recharge.id,赠送发放为空)',
`biz_no` varchar(64) NOT NULL COMMENT '幂等键(充值=recharge:{订单ID},赠送=gift:{赠号})',
`amount` decimal(10, 2) NOT NULL COMMENT '发放额度(元)',
`status` tinyint NOT NULL DEFAULT 0 COMMENT '发放状态(0-未发放成功/失败待重试,1-已发放)',
`fail_reason` varchar(500) DEFAULT NULL COMMENT '发放失败原因',
`operator_id` bigint DEFAULT NULL COMMENT '操作人ID(赠送发放时记录,充值为空)',
`reason` varchar(500) DEFAULT NULL COMMENT '赠送原因',
`api_hub_note` varchar(200) DEFAULT NULL COMMENT '传给 api_hub 的备注(对账用)',
`creator` varchar(64) DEFAULT '' COMMENT '创建者',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updater` varchar(64) DEFAULT '' COMMENT '更新者',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
`deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '删除标志',
`tenant_id` bigint NOT NULL DEFAULT '0' COMMENT '租户编号',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_biz_no` (`biz_no`),
KEY `idx_user_id` (`user_id`),
KEY `idx_biz_type_status` (`biz_type`, `status`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4
COLLATE = utf8mb4_0900_ai_ci COMMENT ='会员额度发放流水';
-- ============== 菜单按钮权限 ==============
-- 「赠送管理」是「会员充值记录」页面(菜单 id=5168)里的一个 tab,不单独建菜单,
-- 只需要在菜单下挂两个按钮权限。
INSERT INTO `system_menu` (name, permission, type, sort, parent_id, path, icon, component, component_name,
status, visible, keep_alive, always_show, creator, create_time, updater, update_time, deleted)
SELECT '查询赠送记录', 'member:quota-grant:query', 3, 3, 5168, '', '', NULL, NULL,
0, b'1', b'1', b'1', 'admin', NOW(), '1', NOW(), b'0'
FROM DUAL
WHERE EXISTS (SELECT 1 FROM `system_menu` WHERE id = 5168 AND deleted = 0)
AND NOT EXISTS (SELECT 1 FROM `system_menu` WHERE permission = 'member:quota-grant:query' AND deleted = 0);
INSERT INTO `system_menu` (name, permission, type, sort, parent_id, path, icon, component, component_name,
status, visible, keep_alive, always_show, creator, create_time, updater, update_time, deleted)
SELECT '发放赠送金', 'member:quota-grant:grant', 3, 4, 5168, '', '', NULL, NULL,
0, b'1', b'1', b'1', 'admin', NOW(), '1', NOW(), b'0'
FROM DUAL
WHERE EXISTS (SELECT 1 FROM `system_menu` WHERE id = 5168 AND deleted = 0)
AND NOT EXISTS (SELECT 1 FROM `system_menu` WHERE permission = 'member:quota-grant:grant' AND deleted = 0);
-- 超级管理员(role_id=1)默认拥有全部权限,无需授权;
-- 如需给其他角色授权,取消下面注释并替换 role_id 执行:
-- INSERT INTO `system_role_menu` (role_id, menu_id, creator, create_time, updater, update_time, deleted, tenant_id)
-- SELECT 1, id, 'admin', NOW(), '1', NOW(), b'0', 0
-- FROM `system_menu`
-- WHERE permission IN ('member:quota-grant:query', 'member:quota-grant:grant') AND deleted = 0;
-- ============================================================
-- 修正 member_quota_grant 发放流水的租户归属
-- 创建时间:2026-11-18
-- 执行环境:测试库 / 正式库(正式库需先导入 2026_11_18_prod_api_hub_migration.sql 建表)
-- ============================================================
--
-- 【背景】
-- WPGJ 支付回调 /admin-api/member/wpgj/notify 登记在 computility.tenant.ignore-urls 中,
-- 回调请求不带 tenant-id 请求头 -> 租户上下文为空 -> 回调写入的充值流水 tenant_id = 0。
-- 而管理端(租户 1)查询流水会由多租户拦截器自动拼上 tenant_id = 1 -> 查不到这些流水 ->
-- 点「人工充值」时被当成新记录 INSERT -> 撞 uk_biz_no 唯一索引 -> 事务回滚 ->
-- 界面表现为「点了没反应」,库里只剩一句「人工充值失败」。
--
-- 【处理】
-- 代码已修复:回调路径显式切换到充值记录所属租户(TenantUtils.execute),
-- 新产生的流水 tenant_id 与 member_recharge 一致。
-- 本脚本用于把历史脏数据订正为充值记录所属的租户,**可重复执行**(只改 tenant_id = 0 的行)。
-- 先看一眼待订正的数据(只读)
SELECT g.id,
g.biz_no,
g.biz_type,
g.status,
g.tenant_id AS grant_tenant_id,
r.tenant_id AS recharge_tenant_id,
LEFT(g.fail_reason, 60) AS fail_reason
FROM `member_quota_grant` g
LEFT JOIN `member_recharge` r ON r.id = g.biz_id AND r.deleted = 0
WHERE g.biz_type = 1
AND g.deleted = 0
ORDER BY g.id;
-- 订正:充值到账流水的租户号,对齐到它所属的充值记录
UPDATE `member_quota_grant` g
JOIN `member_recharge` r ON r.id = g.biz_id AND r.deleted = 0
SET g.tenant_id = r.tenant_id
WHERE g.biz_type = 1
AND g.deleted = 0
AND g.tenant_id = 0
AND r.tenant_id IS NOT NULL
AND r.tenant_id <> 0;
-- 校验(只读):确认流水与充值记录的租户号已一致
SELECT g.id,
g.biz_no,
g.biz_type,
g.status,
g.tenant_id AS grant_tenant_id,
r.tenant_id AS recharge_tenant_id,
LEFT(g.fail_reason, 60) AS fail_reason
FROM `member_quota_grant` g
LEFT JOIN `member_recharge` r ON r.id = g.biz_id
ORDER BY g.id;
-- ============================================================================
-- 【正式环境专用】api_hub 迁移 · 阶段 1 + 阶段 5 合并脚本
--
-- 目标库:jdbc:mysql://8.136.9.68:3306/new_computility(application-prod.yaml)
-- 用法:由人工在正式库执行,执行前请先备份 member_user / system_menu 两张表。
--
-- 合并内容:
-- 阶段 1 → member_user 增加 api_hub_* 5 列
-- (原 2026_11_11_add_member_user_api_hub_fields.sql + ..._password.sql)
-- 阶段 5 → member_quota_grant 额度发放流水表 + 「赠送管理」菜单按钮权限
--
-- 与开发环境脚本的差异:
-- 1. system_menu 插入不带固定 id,由数据库自增分配(正式库 MAX(id)=5174)
-- 2. 父菜单 id 不写死 5168,改为按菜单名「会员充值记录」动态查找
-- (开发库与正式库的 system_menu 主键/排序并不一致,不能照抄 id)
-- 3. member_user 的 ADD COLUMN 用动态 SQL + information_schema 判断,
-- 做到可重复执行(MySQL 8.0 不支持 ADD COLUMN IF NOT EXISTS)
--
-- 幂等性:全部语句可重复执行,已存在的对象会跳过,不会报错。
-- ============================================================================
USE `new_computility`;
-- ############################################################################
-- 一、阶段 1:member_user 增加 api_hub 相关字段
--
-- api_hub_user_id api_hub 侧 users.id,阶段 5 topup 的路径参数
-- api_hub_username api_hub 登录账号
-- api_hub_password api_hub 登录密码(明文,便于用户登录控制台 / 重置密码)
-- api_hub_token_id api_hub 密钥 id
-- api_hub_key api_hub API Key(明文)
--
-- newapi_* 5 列暂不删除(develop 分支仍在用),两套字段并存互不影响。
-- 列顺序与开发库保持一致:newapi_password → api_hub_user_id → api_hub_username
-- → api_hub_password → api_hub_token_id → api_hub_key
-- ############################################################################
-- 1.1 api_hub_user_id
SET @ddl := (
SELECT IF(COUNT(*) = 0,
'ALTER TABLE `member_user` ADD COLUMN `api_hub_user_id` BIGINT DEFAULT NULL COMMENT ''api_hub 用户ID'' AFTER `newapi_password`',
'SELECT ''api_hub_user_id 已存在,跳过'' AS `info`')
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = 'new_computility' AND TABLE_NAME = 'member_user' AND COLUMN_NAME = 'api_hub_user_id'
);
PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
-- 1.2 api_hub_username
SET @ddl := (
SELECT IF(COUNT(*) = 0,
'ALTER TABLE `member_user` ADD COLUMN `api_hub_username` VARCHAR(64) DEFAULT NULL COMMENT ''api_hub 用户名'' AFTER `api_hub_user_id`',
'SELECT ''api_hub_username 已存在,跳过'' AS `info`')
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = 'new_computility' AND TABLE_NAME = 'member_user' AND COLUMN_NAME = 'api_hub_username'
);
PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
-- 1.3 api_hub_password(补充脚本:api_hub 侧只存 password_hash,无明文查询接口)
SET @ddl := (
SELECT IF(COUNT(*) = 0,
'ALTER TABLE `member_user` ADD COLUMN `api_hub_password` VARCHAR(128) DEFAULT NULL COMMENT ''api_hub 登录密码(明文)'' AFTER `api_hub_username`',
'SELECT ''api_hub_password 已存在,跳过'' AS `info`')
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = 'new_computility' AND TABLE_NAME = 'member_user' AND COLUMN_NAME = 'api_hub_password'
);
PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
-- 1.4 api_hub_token_id
SET @ddl := (
SELECT IF(COUNT(*) = 0,
'ALTER TABLE `member_user` ADD COLUMN `api_hub_token_id` BIGINT DEFAULT NULL COMMENT ''api_hub 密钥ID'' AFTER `api_hub_password`',
'SELECT ''api_hub_token_id 已存在,跳过'' AS `info`')
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = 'new_computility' AND TABLE_NAME = 'member_user' AND COLUMN_NAME = 'api_hub_token_id'
);
PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
-- 1.5 api_hub_key
SET @ddl := (
SELECT IF(COUNT(*) = 0,
'ALTER TABLE `member_user` ADD COLUMN `api_hub_key` VARCHAR(255) DEFAULT NULL COMMENT ''api_hub API Key(明文)'' AFTER `api_hub_token_id`',
'SELECT ''api_hub_key 已存在,跳过'' AS `info`')
FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = 'new_computility' AND TABLE_NAME = 'member_user' AND COLUMN_NAME = 'api_hub_key'
);
PREPARE stmt FROM @ddl; EXECUTE stmt; DEALLOCATE PREPARE stmt;
-- ############################################################################
-- 二、阶段 5:会员额度发放流水表
--
-- 记录 puhui 侧所有「给 api_hub 用户加额度」的动作:
-- biz_type=1 充值到账:支付成功回调触发,关联 member_recharge.id
-- biz_type=2 赠送发放:运营在管理端手动发放
-- 发放失败(status=0)保留失败原因,供人工补偿重试;
-- biz_no 唯一索引保证同一笔业务不会重复发放额度(支付重复回调、人工补发都靠它兜底)。
-- ############################################################################
CREATE TABLE IF NOT EXISTS `member_quota_grant`
(
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`user_id` bigint NOT NULL COMMENT '用户ID',
`biz_type` tinyint NOT NULL COMMENT '业务类型(1-充值到账,2-赠送发放)',
`biz_id` bigint DEFAULT NULL COMMENT '关联业务ID(充值到账=member_recharge.id,赠送发放为空)',
`biz_no` varchar(64) NOT NULL COMMENT '幂等键(充值=recharge:{订单ID},赠送=gift:{赠号})',
`amount` decimal(10, 2) NOT NULL COMMENT '发放额度(元)',
`status` tinyint NOT NULL DEFAULT 0 COMMENT '发放状态(0-未发放成功/失败待重试,1-已发放)',
`fail_reason` varchar(500) DEFAULT NULL COMMENT '发放失败原因',
`operator_id` bigint DEFAULT NULL COMMENT '操作人ID(赠送发放时记录,充值为空)',
`reason` varchar(500) DEFAULT NULL COMMENT '赠送原因',
`api_hub_note` varchar(200) DEFAULT NULL COMMENT '传给 api_hub 的备注(对账用)',
`creator` varchar(64) DEFAULT '' COMMENT '创建者',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updater` varchar(64) DEFAULT '' COMMENT '更新者',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
`deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '删除标志',
`tenant_id` bigint NOT NULL DEFAULT '0' COMMENT '租户编号',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_biz_no` (`biz_no`),
KEY `idx_user_id` (`user_id`),
KEY `idx_biz_type_status` (`biz_type`, `status`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4
COLLATE = utf8mb4_0900_ai_ci COMMENT ='会员额度发放流水';
-- ############################################################################
-- 三、阶段 5:「赠送管理」菜单按钮权限
--
-- 「赠送管理」是「会员充值记录」页面里的一个 tab,不单独建菜单,
-- 只需在「会员充值记录」菜单下挂两个按钮权限。
--
-- id 不指定,由 system_menu 的 AUTO_INCREMENT 分配;
-- parent_id 通过子查询按菜单名定位,避免写死主键 id。
-- ############################################################################
-- 按钮一:查询赠送记录
INSERT INTO `system_menu` (name, permission, type, sort, parent_id, path, icon, component, component_name,
status, visible, keep_alive, always_show, creator, create_time, updater, update_time, deleted)
SELECT '查询赠送记录', 'member:quota-grant:query', 3, 3, p.`id`, '', '', NULL, NULL,
0, b'1', b'1', b'1', 'admin', NOW(), '1', NOW(), b'0'
FROM (SELECT `id`
FROM `system_menu`
WHERE `name` = '会员充值记录' AND `type` = 2 AND `deleted` = 0
ORDER BY `id`
LIMIT 1) p
WHERE NOT EXISTS (SELECT 1 FROM `system_menu` WHERE `permission` = 'member:quota-grant:query' AND `deleted` = 0);
-- 按钮二:发放赠送金
INSERT INTO `system_menu` (name, permission, type, sort, parent_id, path, icon, component, component_name,
status, visible, keep_alive, always_show, creator, create_time, updater, update_time, deleted)
SELECT '发放赠送金', 'member:quota-grant:grant', 3, 4, p.`id`, '', '', NULL, NULL,
0, b'1', b'1', b'1', 'admin', NOW(), '1', NOW(), b'0'
FROM (SELECT `id`
FROM `system_menu`
WHERE `name` = '会员充值记录' AND `type` = 2 AND `deleted` = 0
ORDER BY `id`
LIMIT 1) p
WHERE NOT EXISTS (SELECT 1 FROM `system_menu` WHERE `permission` = 'member:quota-grant:grant' AND `deleted` = 0);
-- ############################################################################
-- 四、角色授权(按需启用)
--
-- 超级管理员(role_id=1)默认拥有全部权限,无需授权;
-- 如需给其他角色授权,取消下面注释并替换 role_id 执行:
-- ############################################################################
-- INSERT INTO `system_role_menu` (role_id, menu_id, creator, create_time, updater, update_time, deleted, tenant_id)
-- SELECT 1, m.`id`, 'admin', NOW(), '1', NOW(), b'0', 0
-- FROM `system_menu` m
-- WHERE m.`permission` IN ('member:quota-grant:query', 'member:quota-grant:grant') AND m.`deleted` = 0;
-- ############################################################################
-- 五、执行后校验(只读)
-- ############################################################################
-- 1) 确认 member_user 的 api_hub_* 5 列已加齐,顺序正确:
-- SELECT ORDINAL_POSITION, COLUMN_NAME, COLUMN_TYPE
-- FROM information_schema.COLUMNS
-- WHERE TABLE_SCHEMA = 'new_computility' AND TABLE_NAME = 'member_user'
-- AND (COLUMN_NAME LIKE 'api_hub%' OR COLUMN_NAME LIKE 'newapi%')
-- ORDER BY ORDINAL_POSITION;
-- 2) 确认 member_quota_grant 表已创建:
-- SELECT TABLE_NAME, TABLE_COMMENT FROM information_schema.TABLES
-- WHERE TABLE_SCHEMA = 'new_computility' AND TABLE_NAME = 'member_quota_grant';
-- 3) 确认两个按钮权限已挂到「会员充值记录」下:
-- SELECT m.id AS 父菜单id, m.name AS 父菜单, c.id AS 按钮id, c.name AS 按钮名,
-- c.permission AS 权限标识, c.sort
-- FROM system_menu m
-- JOIN system_menu c ON c.parent_id = m.id AND c.deleted = 0
-- WHERE m.name = '会员充值记录' AND m.deleted = 0
-- AND c.permission IN ('member:quota-grant:query', 'member:quota-grant:grant');
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment