package com.vincent.rsf.server.ai.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.ai.config.AiDefaults;
|
import com.vincent.rsf.server.ai.dto.AiChatModelOptionDto;
|
import com.vincent.rsf.server.ai.dto.AiParamValidateResultDto;
|
import com.vincent.rsf.server.ai.entity.AiParam;
|
import com.vincent.rsf.server.ai.mapper.AiParamMapper;
|
import com.vincent.rsf.server.ai.service.AiParamService;
|
import com.vincent.rsf.server.system.enums.StatusType;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
import java.text.SimpleDateFormat;
|
import java.util.Date;
|
import java.util.List;
|
|
@Service("aiParamService")
|
@RequiredArgsConstructor
|
public class AiParamServiceImpl extends ServiceImpl<AiParamMapper, AiParam> implements AiParamService {
|
|
private final AiParamValidationSupport aiParamValidationSupport;
|
private final AiRedisSupport aiRedisSupport;
|
|
@Override
|
public AiParam getActiveParam(Long tenantId) {
|
ensureTenantId(tenantId);
|
AiParam aiParam = this.getOne(new LambdaQueryWrapper<AiParam>()
|
.eq(AiParam::getTenantId, tenantId)
|
.eq(AiParam::getStatus, StatusType.ENABLE.val)
|
.eq(AiParam::getDeleted, 0)
|
.last("limit 1"));
|
if (aiParam == null) {
|
throw new CoolException("未找到启用中的 AI 参数配置");
|
}
|
return aiParam;
|
}
|
|
@Override
|
public AiParam getChatParam(Long tenantId, Long aiParamId) {
|
ensureTenantId(tenantId);
|
if (aiParamId == null) {
|
return getActiveParam(tenantId);
|
}
|
AiParam aiParam = requireOwnedRecord(aiParamId, tenantId);
|
if (!AiDefaults.PARAM_VALIDATE_VALID.equals(aiParam.getValidateStatus())) {
|
throw new CoolException("所选 AI 模型未通过校验，暂不可用于对话");
|
}
|
return aiParam;
|
}
|
|
@Override
|
public List<AiChatModelOptionDto> listChatModelOptions(Long tenantId) {
|
ensureTenantId(tenantId);
|
List<AiParam> params = this.list(new LambdaQueryWrapper<AiParam>()
|
.eq(AiParam::getTenantId, tenantId)
|
.eq(AiParam::getDeleted, 0)
|
.eq(AiParam::getValidateStatus, AiDefaults.PARAM_VALIDATE_VALID)
|
.orderByDesc(AiParam::getStatus)
|
.orderByDesc(AiParam::getUpdateTime)
|
.orderByDesc(AiParam::getCreateTime)
|
.orderByDesc(AiParam::getId));
|
if (params.isEmpty()) {
|
return List.of(toChatModelOption(getActiveParam(tenantId)));
|
}
|
return params.stream()
|
.map(this::toChatModelOption)
|
.toList();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public AiParam setDefaultParam(Long id, Long tenantId, Long userId) {
|
ensureTenantId(tenantId);
|
if (id == null) {
|
throw new CoolException("AI 参数 ID 不能为空");
|
}
|
AiParam target = requireOwnedRecord(id, tenantId);
|
if (!AiDefaults.PARAM_VALIDATE_VALID.equals(target.getValidateStatus())) {
|
throw new CoolException("仅允许将校验通过的 AI 参数设置为默认");
|
}
|
Date now = new Date();
|
this.lambdaUpdate()
|
.eq(AiParam::getTenantId, tenantId)
|
.eq(AiParam::getDeleted, 0)
|
.set(AiParam::getStatus, StatusType.DISABLE.val)
|
.set(AiParam::getUpdateBy, userId)
|
.set(AiParam::getUpdateTime, now)
|
.update();
|
target.setStatus(StatusType.ENABLE.val);
|
target.setUpdateBy(userId);
|
target.setUpdateTime(now);
|
if (!super.updateById(target)) {
|
throw new CoolException("设置默认 AI 参数失败");
|
}
|
aiRedisSupport.evictTenantConfigCaches(tenantId);
|
return target;
|
}
|
|
@Override
|
public void validateBeforeSave(AiParam aiParam, Long tenantId) {
|
ensureTenantId(tenantId);
|
aiParam.setTenantId(tenantId);
|
fillDefaults(aiParam);
|
ensureBaseFields(aiParam);
|
ensureSingleActive(tenantId, null, aiParam.getStatus());
|
applyValidation(aiParam);
|
}
|
|
@Override
|
public void validateBeforeUpdate(AiParam aiParam, Long tenantId) {
|
ensureTenantId(tenantId);
|
fillDefaults(aiParam);
|
if (aiParam.getId() == null) {
|
throw new CoolException("AI 参数 ID 不能为空");
|
}
|
AiParam current = requireOwnedRecord(aiParam.getId(), tenantId);
|
aiParam.setTenantId(current.getTenantId());
|
ensureBaseFields(aiParam);
|
ensureDefaultStillExists(tenantId, current, aiParam.getStatus());
|
ensureSingleActive(tenantId, aiParam.getId(), aiParam.getStatus());
|
applyValidation(aiParam);
|
}
|
|
@Override
|
public AiParamValidateResultDto validateDraft(AiParam aiParam, Long tenantId) {
|
ensureTenantId(tenantId);
|
fillDefaults(aiParam);
|
ensureBaseFields(aiParam);
|
return aiParamValidationSupport.validate(aiParam);
|
}
|
|
@Override
|
public boolean save(AiParam entity) {
|
boolean saved = super.save(entity);
|
if (saved && entity != null && entity.getTenantId() != null) {
|
aiRedisSupport.evictTenantConfigCaches(entity.getTenantId());
|
}
|
return saved;
|
}
|
|
@Override
|
public boolean updateById(AiParam entity) {
|
boolean updated = super.updateById(entity);
|
if (updated && entity != null && entity.getTenantId() != null) {
|
aiRedisSupport.evictTenantConfigCaches(entity.getTenantId());
|
}
|
return updated;
|
}
|
|
@Override
|
public boolean removeByIds(java.util.Collection<?> list) {
|
java.util.List<java.io.Serializable> ids = list == null ? java.util.List.of() : list.stream()
|
.filter(java.util.Objects::nonNull)
|
.map(item -> (java.io.Serializable) item)
|
.toList();
|
java.util.List<AiParam> records = this.listByIds(ids);
|
ensureRemovingDefaultIsSafe(records);
|
boolean removed = super.removeByIds(list);
|
if (removed) {
|
records.stream()
|
.map(AiParam::getTenantId)
|
.filter(java.util.Objects::nonNull)
|
.distinct()
|
.forEach(aiRedisSupport::evictTenantConfigCaches);
|
}
|
return removed;
|
}
|
|
private void ensureBaseFields(AiParam aiParam) {
|
if (!StringUtils.hasText(aiParam.getName())) {
|
throw new CoolException("AI 参数名称不能为空");
|
}
|
if (!StringUtils.hasText(aiParam.getProviderType())) {
|
aiParam.setProviderType(AiDefaults.PROVIDER_OPENAI_COMPATIBLE);
|
}
|
if (!StringUtils.hasText(aiParam.getBaseUrl())) {
|
throw new CoolException("AI Base URL 不能为空");
|
}
|
if (!StringUtils.hasText(aiParam.getApiKey())) {
|
throw new CoolException("AI API Key 不能为空");
|
}
|
if (!StringUtils.hasText(aiParam.getModel())) {
|
throw new CoolException("AI 模型不能为空");
|
}
|
}
|
|
private void ensureSingleActive(Long tenantId, Long selfId, Integer status) {
|
if (status == null || status != StatusType.ENABLE.val) {
|
return;
|
}
|
LambdaQueryWrapper<AiParam> wrapper = new LambdaQueryWrapper<AiParam>()
|
.eq(AiParam::getTenantId, tenantId)
|
.eq(AiParam::getStatus, StatusType.ENABLE.val)
|
.eq(AiParam::getDeleted, 0);
|
if (selfId != null) {
|
wrapper.ne(AiParam::getId, selfId);
|
}
|
if (this.count(wrapper) > 0) {
|
throw new CoolException("同一租户仅允许一条启用中的 AI 参数配置");
|
}
|
}
|
|
private void ensureDefaultStillExists(Long tenantId, AiParam current, Integer nextStatus) {
|
if (current == null || current.getStatus() == null || current.getStatus() != StatusType.ENABLE.val) {
|
return;
|
}
|
if (nextStatus != null && nextStatus == StatusType.ENABLE.val) {
|
return;
|
}
|
long otherDefaultCount = this.count(new LambdaQueryWrapper<AiParam>()
|
.eq(AiParam::getTenantId, tenantId)
|
.eq(AiParam::getDeleted, 0)
|
.eq(AiParam::getStatus, StatusType.ENABLE.val)
|
.ne(AiParam::getId, current.getId()));
|
if (otherDefaultCount == 0) {
|
throw new CoolException("请先将其他 AI 参数设置为默认，再取消当前默认");
|
}
|
}
|
|
private void ensureRemovingDefaultIsSafe(List<AiParam> records) {
|
if (records == null || records.isEmpty()) {
|
return;
|
}
|
records.stream()
|
.filter(item -> item.getTenantId() != null && item.getStatus() != null && item.getStatus() == StatusType.ENABLE.val)
|
.map(AiParam::getTenantId)
|
.distinct()
|
.forEach(this::ensureTenantHasRemainingDefaultAfterRemove);
|
}
|
|
private void ensureTenantHasRemainingDefaultAfterRemove(Long tenantId) {
|
long defaultCount = this.count(new LambdaQueryWrapper<AiParam>()
|
.eq(AiParam::getTenantId, tenantId)
|
.eq(AiParam::getDeleted, 0)
|
.eq(AiParam::getStatus, StatusType.ENABLE.val));
|
if (defaultCount <= 1) {
|
throw new CoolException("默认 AI 参数不能直接删除，请先将其他配置设为默认");
|
}
|
}
|
|
private AiParam requireOwnedRecord(Long id, Long tenantId) {
|
AiParam aiParam = this.getOne(new LambdaQueryWrapper<AiParam>()
|
.eq(AiParam::getId, id)
|
.eq(AiParam::getTenantId, tenantId)
|
.eq(AiParam::getDeleted, 0)
|
.last("limit 1"));
|
if (aiParam == null) {
|
throw new CoolException("AI 参数不存在或无权访问");
|
}
|
return aiParam;
|
}
|
|
private void ensureTenantId(Long tenantId) {
|
if (tenantId == null) {
|
throw new CoolException("当前租户不存在");
|
}
|
}
|
|
private void fillDefaults(AiParam aiParam) {
|
if (!StringUtils.hasText(aiParam.getProviderType())) {
|
aiParam.setProviderType(AiDefaults.PROVIDER_OPENAI_COMPATIBLE);
|
}
|
if (aiParam.getTemperature() == null) {
|
aiParam.setTemperature(AiDefaults.DEFAULT_TEMPERATURE);
|
}
|
if (aiParam.getTopP() == null) {
|
aiParam.setTopP(AiDefaults.DEFAULT_TOP_P);
|
}
|
if (aiParam.getTimeoutMs() == null) {
|
aiParam.setTimeoutMs(AiDefaults.DEFAULT_TIMEOUT_MS);
|
}
|
if (aiParam.getStreamingEnabled() == null) {
|
aiParam.setStreamingEnabled(Boolean.TRUE);
|
}
|
if (!StringUtils.hasText(aiParam.getValidateStatus())) {
|
aiParam.setValidateStatus(AiDefaults.PARAM_VALIDATE_NOT_TESTED);
|
}
|
if (aiParam.getStatus() == null) {
|
aiParam.setStatus(StatusType.ENABLE.val);
|
}
|
}
|
|
private void applyValidation(AiParam aiParam) {
|
AiParamValidateResultDto validateResult = aiParamValidationSupport.validate(aiParam);
|
aiParam.setValidateStatus(validateResult.getStatus());
|
aiParam.setLastValidateMessage(validateResult.getMessage());
|
aiParam.setLastValidateElapsedMs(validateResult.getElapsedMs());
|
aiParam.setLastValidateTime(parseDate(validateResult.getValidatedAt()));
|
if (!AiDefaults.PARAM_VALIDATE_VALID.equals(validateResult.getStatus())) {
|
throw new CoolException(validateResult.getMessage());
|
}
|
}
|
|
private Date parseDate(String dateTime) {
|
if (!StringUtils.hasText(dateTime)) {
|
return null;
|
}
|
try {
|
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateTime);
|
} catch (Exception e) {
|
throw new CoolException("解析校验时间失败: " + e.getMessage());
|
}
|
}
|
|
private AiChatModelOptionDto toChatModelOption(AiParam aiParam) {
|
return AiChatModelOptionDto.builder()
|
.aiParamId(aiParam.getId())
|
.name(aiParam.getName())
|
.model(aiParam.getModel())
|
.providerType(aiParam.getProviderType())
|
.active(aiParam.getStatus() != null && aiParam.getStatus() == StatusType.ENABLE.val)
|
.build();
|
}
|
}
|
