ab7f029960
Allows editors to update release notes at any time. Every change is recorded in update_operation_log with action CHANGELOG_UPDATE and before/after values in detailJson, satisfying the audit requirement. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
473 行
23 KiB
Java
473 行
23 KiB
Java
package com.xuqm.update.controller;
|
||
|
||
import com.xuqm.common.model.ApiResponse;
|
||
import com.xuqm.update.entity.AppVersionEntity;
|
||
import com.xuqm.update.repository.AppVersionRepository;
|
||
import com.xuqm.update.model.AppPackageInspectResult;
|
||
import com.xuqm.update.service.UpdateOperationLogService;
|
||
import org.slf4j.Logger;
|
||
import org.slf4j.LoggerFactory;
|
||
import org.springframework.http.ResponseEntity;
|
||
import org.springframework.web.bind.annotation.*;
|
||
import org.springframework.web.multipart.MultipartFile;
|
||
|
||
import java.time.LocalDateTime;
|
||
import java.time.format.DateTimeParseException;
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
import java.util.Optional;
|
||
import java.util.UUID;
|
||
import com.xuqm.update.service.UpdateAssetService;
|
||
import com.xuqm.update.service.PublishConfigService;
|
||
import com.xuqm.update.service.AppStoreService;
|
||
import com.xuqm.update.service.ImPushUserClient;
|
||
|
||
@RestController
|
||
@RequestMapping("/api/v1/updates")
|
||
public class AppVersionController {
|
||
|
||
private static final Logger log = LoggerFactory.getLogger(AppVersionController.class);
|
||
|
||
private final AppVersionRepository versionRepository;
|
||
private final UpdateAssetService updateAssetService;
|
||
private final PublishConfigService publishConfigService;
|
||
private final AppStoreService appStoreService;
|
||
private final UpdateOperationLogService operationLogService;
|
||
|
||
private final ImPushUserClient imPushUserClient;
|
||
|
||
public AppVersionController(AppVersionRepository versionRepository,
|
||
UpdateAssetService updateAssetService,
|
||
PublishConfigService publishConfigService,
|
||
AppStoreService appStoreService,
|
||
UpdateOperationLogService operationLogService,
|
||
ImPushUserClient imPushUserClient) {
|
||
this.versionRepository = versionRepository;
|
||
this.updateAssetService = updateAssetService;
|
||
this.publishConfigService = publishConfigService;
|
||
this.appStoreService = appStoreService;
|
||
this.operationLogService = operationLogService;
|
||
this.imPushUserClient = imPushUserClient;
|
||
}
|
||
|
||
@GetMapping("/app/check")
|
||
public ResponseEntity<ApiResponse<Map<String, Object>>> checkUpdate(
|
||
@RequestParam String appKey,
|
||
@RequestParam AppVersionEntity.Platform platform,
|
||
@RequestParam int currentVersionCode,
|
||
@RequestParam(required = false) String userId) {
|
||
|
||
boolean allowAnonymousCheck = publishConfigService.allowAnonymousUpdateCheck(appKey);
|
||
if (!allowAnonymousCheck && (userId == null || userId.isBlank())) {
|
||
return ResponseEntity.ok(ApiResponse.success(Map.of("needsUpdate", false)));
|
||
}
|
||
|
||
Optional<AppVersionEntity> latest = versionRepository
|
||
.findTopByAppKeyAndPlatformAndPublishStatusAndVersionCodeGreaterThanOrderByVersionCodeDesc(
|
||
appKey, platform, AppVersionEntity.PublishStatus.PUBLISHED, currentVersionCode);
|
||
Optional<AppVersionEntity> forcedHigher = versionRepository
|
||
.findTopByAppKeyAndPlatformAndPublishStatusAndVersionCodeGreaterThanAndForceUpdateTrueOrderByVersionCodeDesc(
|
||
appKey, platform, AppVersionEntity.PublishStatus.PUBLISHED, currentVersionCode);
|
||
|
||
if (latest.isEmpty()) {
|
||
return ResponseEntity.ok(ApiResponse.success(Map.of("needsUpdate", false)));
|
||
}
|
||
|
||
AppVersionEntity v = latest.get();
|
||
|
||
// Gray release filtering
|
||
if (!allowAnonymousCheck && v.isGrayEnabled() && userId != null && !userId.isBlank()) {
|
||
boolean inGray = isInGrayRelease(v, userId);
|
||
if (!inGray) {
|
||
return ResponseEntity.ok(ApiResponse.success(Map.of("needsUpdate", false)));
|
||
}
|
||
}
|
||
|
||
String appStoreJumpUrl = hasText(v.getAppStoreUrl())
|
||
? v.getAppStoreUrl()
|
||
: appStoreService.getStoreJumpUrl(appKey, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.APP_STORE);
|
||
String harmonyJumpUrl = hasText(v.getMarketUrl())
|
||
? v.getMarketUrl()
|
||
: appStoreService.getStoreJumpUrl(appKey, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.HARMONY_APP);
|
||
return ResponseEntity.ok(ApiResponse.success(Map.of(
|
||
"needsUpdate", true,
|
||
"versionName", v.getVersionName(),
|
||
"versionCode", v.getVersionCode(),
|
||
"downloadUrl", v.getDownloadUrl() != null ? v.getDownloadUrl() : "",
|
||
"changeLog", v.getChangeLog() != null ? v.getChangeLog() : "",
|
||
"forceUpdate", forcedHigher.isPresent(),
|
||
"appStoreUrl", appStoreJumpUrl,
|
||
"marketUrl", harmonyJumpUrl
|
||
)));
|
||
}
|
||
|
||
@PostMapping("/app/upload")
|
||
public ResponseEntity<ApiResponse<AppVersionEntity>> upload(
|
||
@RequestParam String appKey,
|
||
@RequestParam AppVersionEntity.Platform platform,
|
||
@RequestParam(required = false) String versionName,
|
||
@RequestParam(required = false) Integer versionCode,
|
||
@RequestParam(required = false) String changeLog,
|
||
@RequestParam(defaultValue = "false") boolean forceUpdate,
|
||
@RequestParam(required = false) String apkUrl,
|
||
@RequestParam(required = false) MultipartFile apkFile,
|
||
@RequestParam(required = false) String scheduledPublishAt,
|
||
@RequestParam(required = false) String webhookUrl,
|
||
@RequestParam(required = false) String storeSubmitTargets,
|
||
@RequestParam(defaultValue = "false") boolean autoPublishAfterReview,
|
||
@RequestParam(defaultValue = "false") boolean publishImmediately,
|
||
@RequestParam(required = false) String packageName,
|
||
@RequestParam(required = false) String expectedPackageName,
|
||
@RequestParam(required = false) String appStoreUrl,
|
||
@RequestParam(required = false) String marketUrl) throws Exception {
|
||
|
||
AppPackageInspectResult inspected = null;
|
||
try {
|
||
inspected = hasText(apkUrl)
|
||
? updateAssetService.inspectAppPackage(apkUrl)
|
||
: (apkFile != null && !apkFile.isEmpty() ? updateAssetService.inspectAppPackage(apkFile) : null);
|
||
} catch (Exception ex) {
|
||
log.warn("Unable to inspect upload package for appKey={}, platform={}, source={}, fallback to manual version fields: {}",
|
||
appKey, platform, hasText(apkUrl) ? apkUrl : (apkFile != null ? apkFile.getOriginalFilename() : null), ex.getMessage());
|
||
}
|
||
String resolvedVersionName = hasText(versionName) ? versionName : (inspected != null ? inspected.versionName() : null);
|
||
Integer resolvedVersionCode = versionCode != null ? versionCode : (inspected != null ? inspected.versionCode() : null);
|
||
String resolvedPackageName = hasText(packageName) ? packageName : (inspected != null ? inspected.packageName() : null);
|
||
if (!hasText(resolvedVersionName) || resolvedVersionCode == null) {
|
||
throw new IllegalArgumentException("versionName and versionCode are required or must be readable from the uploaded package");
|
||
}
|
||
if (hasText(expectedPackageName) && hasText(resolvedPackageName) && !expectedPackageName.equals(resolvedPackageName)) {
|
||
throw new IllegalArgumentException("packageName does not match current app packageName");
|
||
}
|
||
if (platform == AppVersionEntity.Platform.ANDROID && !hasText(apkUrl) && (apkFile == null || apkFile.isEmpty())) {
|
||
throw new IllegalArgumentException("apkUrl or apkFile is required for ANDROID releases");
|
||
}
|
||
AppVersionEntity entity = new AppVersionEntity();
|
||
entity.setId(UUID.randomUUID().toString());
|
||
entity.setAppKey(appKey);
|
||
entity.setPlatform(platform);
|
||
entity.setVersionName(resolvedVersionName);
|
||
entity.setVersionCode(resolvedVersionCode);
|
||
entity.setDownloadUrl(platform == AppVersionEntity.Platform.ANDROID
|
||
? (hasText(apkUrl) ? apkUrl : updateAssetService.storeAppPackage(apkFile))
|
||
: null);
|
||
entity.setChangeLog(changeLog);
|
||
entity.setForceUpdate(forceUpdate);
|
||
entity.setPublishStatus(AppVersionEntity.PublishStatus.DRAFT);
|
||
entity.setCreatedAt(LocalDateTime.now());
|
||
entity.setStoreSubmitMode("MANUAL");
|
||
entity.setStoreSubmitScheduledAt(null);
|
||
entity.setGrayMode(AppVersionEntity.GrayMode.PERCENT);
|
||
entity.setGrayMemberIds(null);
|
||
if (scheduledPublishAt != null && !scheduledPublishAt.isBlank()) {
|
||
try {
|
||
entity.setScheduledPublishAt(LocalDateTime.parse(scheduledPublishAt));
|
||
} catch (DateTimeParseException e) {
|
||
throw new IllegalArgumentException("scheduledPublishAt 格式无效，应为 ISO-8601（如 2026-05-01T10:00:00）");
|
||
}
|
||
}
|
||
entity.setWebhookUrl(webhookUrl);
|
||
entity.setStoreSubmitTargets(storeSubmitTargets);
|
||
entity.setAutoPublishAfterReview(autoPublishAfterReview);
|
||
entity.setPackageName(resolvedPackageName);
|
||
entity.setAppStoreUrl(hasText(appStoreUrl)
|
||
? appStoreUrl
|
||
: (platform == AppVersionEntity.Platform.IOS
|
||
? appStoreService.getStoreJumpUrl(appKey, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.APP_STORE)
|
||
: null));
|
||
entity.setMarketUrl(hasText(marketUrl)
|
||
? marketUrl
|
||
: (platform == AppVersionEntity.Platform.HARMONY
|
||
? appStoreService.getStoreJumpUrl(appKey, com.xuqm.update.entity.AppStoreConfigEntity.StoreType.HARMONY_APP)
|
||
: null));
|
||
if (publishImmediately) {
|
||
entity.setPublishStatus(AppVersionEntity.PublishStatus.PUBLISHED);
|
||
entity.setGrayEnabled(false);
|
||
entity.setGrayPercent(0);
|
||
}
|
||
AppVersionEntity saved = versionRepository.save(entity);
|
||
operationLogService.record(
|
||
saved.getAppKey(),
|
||
"APP_VERSION",
|
||
saved.getId(),
|
||
"UPLOAD",
|
||
null,
|
||
Map.of(
|
||
"platform", saved.getPlatform().name(),
|
||
"versionName", saved.getVersionName(),
|
||
"versionCode", saved.getVersionCode(),
|
||
"publishImmediately", publishImmediately,
|
||
"forceUpdate", saved.isForceUpdate(),
|
||
"packageName", saved.getPackageName() == null ? "" : saved.getPackageName()
|
||
));
|
||
return ResponseEntity.ok(ApiResponse.success(saved));
|
||
}
|
||
|
||
@RequestMapping(value = "/app/inspect", method = {RequestMethod.GET, RequestMethod.POST})
|
||
public ResponseEntity<ApiResponse<AppPackageInspectResult>> inspect(
|
||
@RequestParam(required = false) String apkUrl,
|
||
@RequestParam(required = false) MultipartFile apkFile) throws Exception {
|
||
if (hasText(apkUrl)) {
|
||
return ResponseEntity.ok(ApiResponse.success(updateAssetService.inspectAppPackage(apkUrl)));
|
||
}
|
||
return ResponseEntity.ok(ApiResponse.success(updateAssetService.inspectAppPackage(apkFile)));
|
||
}
|
||
|
||
@PostMapping("/app/{id}/publish")
|
||
public ResponseEntity<ApiResponse<AppVersionEntity>> publish(
|
||
@PathVariable String id,
|
||
@RequestBody(required = false) Map<String, Object> body) {
|
||
AppVersionEntity entity = versionRepository.findById(id).orElseThrow();
|
||
boolean publishImmediately = body == null || !Boolean.FALSE.equals(body.get("publishImmediately"));
|
||
String scheduledPublishAt = body != null && body.get("scheduledPublishAt") != null
|
||
? body.get("scheduledPublishAt").toString() : null;
|
||
boolean forceUpdate = body != null && body.get("forceUpdate") != null
|
||
? Boolean.parseBoolean(body.get("forceUpdate").toString()) : entity.isForceUpdate();
|
||
AppVersionEntity.PublishStatus previousStatus = entity.getPublishStatus();
|
||
entity.setForceUpdate(forceUpdate);
|
||
if (publishImmediately && (scheduledPublishAt == null || scheduledPublishAt.isBlank())) {
|
||
entity.setPublishStatus(AppVersionEntity.PublishStatus.PUBLISHED);
|
||
entity.setScheduledPublishAt(null);
|
||
} else {
|
||
entity.setPublishStatus(AppVersionEntity.PublishStatus.DRAFT);
|
||
if (scheduledPublishAt != null && !scheduledPublishAt.isBlank()) {
|
||
try {
|
||
entity.setScheduledPublishAt(LocalDateTime.parse(scheduledPublishAt));
|
||
} catch (DateTimeParseException e) {
|
||
throw new IllegalArgumentException("scheduledPublishAt 格式无效，应为 ISO-8601（如 2026-05-01T10:00:00）");
|
||
}
|
||
}
|
||
}
|
||
entity.setGrayEnabled(false);
|
||
entity.setGrayPercent(0);
|
||
entity.setGrayMode(AppVersionEntity.GrayMode.PERCENT);
|
||
entity.setGrayMemberIds(null);
|
||
entity.setGrayCallbackUrl(null);
|
||
AppVersionEntity saved = versionRepository.save(entity);
|
||
operationLogService.record(
|
||
saved.getAppKey(),
|
||
"APP_VERSION",
|
||
saved.getId(),
|
||
publishAction(previousStatus, saved.getPublishStatus(), publishImmediately),
|
||
null,
|
||
Map.of(
|
||
"versionName", saved.getVersionName(),
|
||
"versionCode", saved.getVersionCode(),
|
||
"publishImmediately", publishImmediately,
|
||
"scheduledPublishAt", saved.getScheduledPublishAt() == null ? "" : saved.getScheduledPublishAt().toString(),
|
||
"forceUpdate", saved.isForceUpdate()
|
||
));
|
||
return ResponseEntity.ok(ApiResponse.success(saved));
|
||
}
|
||
|
||
@PostMapping("/app/{id}/unpublish")
|
||
public ResponseEntity<ApiResponse<AppVersionEntity>> unpublish(
|
||
@PathVariable String id,
|
||
@RequestBody(required = false) Map<String, Object> body) {
|
||
AppVersionEntity entity = versionRepository.findById(id).orElseThrow();
|
||
String reason = body != null && body.get("reason") != null ? body.get("reason").toString().trim() : "";
|
||
if (reason.isBlank()) {
|
||
throw new IllegalArgumentException("unpublish reason is required");
|
||
}
|
||
entity.setPublishStatus(AppVersionEntity.PublishStatus.DEPRECATED);
|
||
AppVersionEntity saved = versionRepository.save(entity);
|
||
operationLogService.record(
|
||
saved.getAppKey(),
|
||
"APP_VERSION",
|
||
saved.getId(),
|
||
"UNPUBLISH",
|
||
reason,
|
||
Map.of(
|
||
"versionName", saved.getVersionName(),
|
||
"versionCode", saved.getVersionCode()
|
||
));
|
||
return ResponseEntity.ok(ApiResponse.success(saved));
|
||
}
|
||
|
||
@PostMapping("/app/{id}/gray")
|
||
public ResponseEntity<ApiResponse<AppVersionEntity>> gray(
|
||
@PathVariable String id,
|
||
@RequestBody Map<String, Object> body) throws Exception {
|
||
AppVersionEntity entity = versionRepository.findById(id).orElseThrow();
|
||
if (publishConfigService.allowAnonymousUpdateCheck(entity.getAppKey())) {
|
||
throw new com.xuqm.common.exception.BusinessException(400, "允许免登录检查更新的应用不支持灰度发布");
|
||
}
|
||
boolean enabled = Boolean.TRUE.equals(body.get("enabled"));
|
||
entity.setGrayEnabled(enabled);
|
||
if (!enabled) {
|
||
entity.setGrayMode(AppVersionEntity.GrayMode.PERCENT);
|
||
entity.setGrayPercent(0);
|
||
entity.setGrayMemberIds(null);
|
||
entity.setGrayCallbackUrl(null);
|
||
} else {
|
||
AppVersionEntity.GrayMode grayMode = parseGrayMode(body.get("grayMode"));
|
||
entity.setGrayMode(grayMode);
|
||
switch (grayMode) {
|
||
case PERCENT -> {
|
||
entity.setGrayPercent(body.get("percent") instanceof Number n ? n.intValue() : 0);
|
||
entity.setGrayMemberIds(null);
|
||
entity.setGrayCallbackUrl(null);
|
||
}
|
||
case IM_PUSH_USERS -> {
|
||
entity.setGrayPercent(0);
|
||
entity.setGrayMemberIds(null);
|
||
entity.setGrayCallbackUrl(null);
|
||
}
|
||
case CUSTOMER_SYNC -> {
|
||
List<String> memberIds = extractMemberIds(body.get("memberIds"));
|
||
if (memberIds.isEmpty()) {
|
||
memberIds = publishConfigService.listSyncedGrayMemberIds(entity.getAppKey());
|
||
}
|
||
entity.setGrayMemberIds(toJson(memberIds));
|
||
entity.setGrayPercent(0);
|
||
entity.setGrayCallbackUrl(null);
|
||
}
|
||
case CUSTOMER_CALLBACK -> {
|
||
String callbackUrl = body.get("callbackUrl") != null ? body.get("callbackUrl").toString().trim() : null;
|
||
if (callbackUrl == null || callbackUrl.isBlank()) {
|
||
throw new IllegalArgumentException("callbackUrl is required for CUSTOMER_CALLBACK gray mode");
|
||
}
|
||
entity.setGrayCallbackUrl(callbackUrl);
|
||
entity.setGrayMemberIds(null);
|
||
entity.setGrayPercent(0);
|
||
}
|
||
}
|
||
}
|
||
entity.setPublishStatus(AppVersionEntity.PublishStatus.PUBLISHED);
|
||
AppVersionEntity saved = versionRepository.save(entity);
|
||
operationLogService.record(
|
||
saved.getAppKey(),
|
||
"APP_VERSION",
|
||
saved.getId(),
|
||
"GRAY_UPDATE",
|
||
null,
|
||
Map.of(
|
||
"enabled", enabled,
|
||
"grayMode", saved.getGrayMode().name(),
|
||
"grayPercent", saved.getGrayPercent(),
|
||
"memberCount", saved.getGrayMemberIds() == null ? 0 : extractMemberIds(saved.getGrayMemberIds()).size()
|
||
));
|
||
return ResponseEntity.ok(ApiResponse.success(saved));
|
||
}
|
||
|
||
private AppVersionEntity.GrayMode parseGrayMode(Object raw) {
|
||
if (raw == null) {
|
||
return AppVersionEntity.GrayMode.PERCENT;
|
||
}
|
||
try {
|
||
return AppVersionEntity.GrayMode.valueOf(raw.toString().trim().toUpperCase());
|
||
} catch (IllegalArgumentException e) {
|
||
return AppVersionEntity.GrayMode.PERCENT;
|
||
}
|
||
}
|
||
|
||
private boolean isInGrayRelease(AppVersionEntity v, String userId) {
|
||
return switch (v.getGrayMode()) {
|
||
case PERCENT -> Math.abs(userId.hashCode()) % 100 < v.getGrayPercent();
|
||
case IM_PUSH_USERS -> imPushUserClient.isImOrPushUser(v.getAppKey(), userId);
|
||
case CUSTOMER_SYNC -> v.getGrayMemberIds() != null && v.getGrayMemberIds().contains(userId);
|
||
case CUSTOMER_CALLBACK -> resolveCallbackGray(v, userId);
|
||
};
|
||
}
|
||
|
||
private boolean resolveCallbackGray(AppVersionEntity v, String userId) {
|
||
if (v.getGrayCallbackUrl() == null || v.getGrayCallbackUrl().isBlank()) {
|
||
return false;
|
||
}
|
||
try {
|
||
List<String> memberIds = publishConfigService.resolveGrayMembersFromUrl(
|
||
v.getGrayCallbackUrl(), v.getAppKey(), userId);
|
||
return memberIds.contains(userId);
|
||
} catch (Exception e) {
|
||
log.warn("Gray callback failed for appKey={} versionId={}: {}", v.getAppKey(), v.getId(), e.getMessage());
|
||
return false;
|
||
}
|
||
}
|
||
|
||
@PatchMapping("/app/{id}/changelog")
|
||
public ResponseEntity<ApiResponse<AppVersionEntity>> updateChangeLog(
|
||
@PathVariable String id,
|
||
@RequestBody Map<String, Object> body) {
|
||
AppVersionEntity entity = versionRepository.findById(id).orElseThrow();
|
||
String oldChangeLog = entity.getChangeLog();
|
||
Object raw = body.get("changeLog");
|
||
String newChangeLog = raw != null && !raw.toString().isBlank() ? raw.toString().trim() : null;
|
||
entity.setChangeLog(newChangeLog);
|
||
AppVersionEntity saved = versionRepository.save(entity);
|
||
operationLogService.record(
|
||
saved.getAppKey(),
|
||
"APP_VERSION",
|
||
saved.getId(),
|
||
"CHANGELOG_UPDATE",
|
||
null,
|
||
Map.of(
|
||
"versionName", saved.getVersionName(),
|
||
"versionCode", saved.getVersionCode(),
|
||
"before", oldChangeLog != null ? oldChangeLog : "",
|
||
"after", newChangeLog != null ? newChangeLog : ""
|
||
));
|
||
return ResponseEntity.ok(ApiResponse.success(saved));
|
||
}
|
||
|
||
@GetMapping("/app/list")
|
||
public ResponseEntity<ApiResponse<List<AppVersionEntity>>> list(
|
||
@RequestParam String appKey, @RequestParam AppVersionEntity.Platform platform) {
|
||
return ResponseEntity.ok(ApiResponse.success(
|
||
versionRepository.findByAppKeyAndPlatformOrderByVersionCodeDesc(appKey, platform)));
|
||
}
|
||
|
||
private String publishAction(AppVersionEntity.PublishStatus previousStatus,
|
||
AppVersionEntity.PublishStatus currentStatus,
|
||
boolean publishImmediately) {
|
||
if (!publishImmediately) {
|
||
return "SCHEDULE_PUBLISH";
|
||
}
|
||
if (previousStatus == AppVersionEntity.PublishStatus.PUBLISHED) {
|
||
return "UPDATE_FORCE";
|
||
}
|
||
if (previousStatus == AppVersionEntity.PublishStatus.DEPRECATED) {
|
||
return "REPUBLISH";
|
||
}
|
||
return currentStatus == AppVersionEntity.PublishStatus.PUBLISHED ? "PUBLISH" : "SAVE_DRAFT";
|
||
}
|
||
|
||
private boolean hasText(String value) {
|
||
return value != null && !value.isBlank();
|
||
}
|
||
|
||
private List<String> extractMemberIds(Object raw) {
|
||
if (raw == null) {
|
||
return List.of();
|
||
}
|
||
if (raw instanceof List<?> list) {
|
||
return list.stream()
|
||
.map(String::valueOf)
|
||
.filter(this::hasText)
|
||
.map(String::trim)
|
||
.toList();
|
||
}
|
||
if (raw instanceof String s) {
|
||
if (!hasText(s)) {
|
||
return List.of();
|
||
}
|
||
try {
|
||
return java.util.Arrays.stream(s.split(","))
|
||
.map(String::trim)
|
||
.filter(this::hasText)
|
||
.toList();
|
||
} catch (Exception ignored) {
|
||
return List.of();
|
||
}
|
||
}
|
||
return List.of();
|
||
}
|
||
|
||
private String toJson(List<String> values) {
|
||
try {
|
||
return new com.fasterxml.jackson.databind.ObjectMapper().writeValueAsString(values == null ? List.of() : values);
|
||
} catch (Exception e) {
|
||
return "[]";
|
||
}
|
||
}
|
||
}
|
