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()));
} }
} }
...@@ -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 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);
}
...@@ -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);
/** /**
* 获取待充值数量 * 获取待充值数量
......
-- ============== 会员额度发放流水表 ==============
-- 记录 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;
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