算子前端展示更新

backend/services/data-cleaning-service/src/main/java/com/datamate/cleaning/application/CleaningTaskService.java

@@ -136,6 +136,9 @@ public CleaningTaskDto createTask(CreateCleaningTaskRequest request) {
         cleaningTaskRepo.insertTask(task);
 
         operatorInstanceRepo.insertInstance(taskId, request.getInstance());
+        operatorRepo.incrementUsageCount(request.getInstance().stream()
+                .map(OperatorInstanceDto::getId)
+                .collect(Collectors.toList()));
 
         prepareTask(task, request.getInstance(), executorType);
         scanDataset(taskId, request.getSrcDatasetId());

backend/services/operator-market-service/src/main/java/com/datamate/operator/application/OperatorService.java

@@ -5,6 +5,7 @@
 import com.datamate.common.infrastructure.exception.BusinessException;
 import com.datamate.common.infrastructure.exception.SystemErrorCode;
 import com.datamate.operator.domain.contants.OperatorConstant;
+import com.datamate.operator.domain.repository.OperatorReleaseRepository;
 import com.datamate.operator.infrastructure.converter.OperatorConverter;
 import com.datamate.operator.domain.model.OperatorView;
 import com.datamate.operator.domain.repository.CategoryRelationRepository;
@@ -13,13 +14,15 @@
 import com.datamate.operator.infrastructure.exception.OperatorErrorCode;
 import com.datamate.operator.infrastructure.parser.ParserHolder;
 import com.datamate.operator.interfaces.dto.OperatorDto;
+import com.datamate.operator.interfaces.dto.OperatorReleaseDto;
 import com.datamate.operator.interfaces.dto.UploadOperatorRequest;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.io.FileUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.io.Resource;
@@ -28,10 +31,16 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.io.File;
+import java.io.IOException;
 import java.net.MalformedURLException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 @Service
 @Slf4j
@@ -43,6 +52,8 @@ public class OperatorService {
 
     private final CategoryRelationRepository relationRepo;
 
+    private final OperatorReleaseRepository operatorReleaseRepo;
+
     private final ParserHolder parserHolder;
 
     private final FileService fileService;
@@ -63,29 +74,57 @@ public int getOperatorsCount(List<List<String>> categories, String keyword, Bool
 
     public OperatorDto getOperatorById(String id) {
         OperatorView operator = operatorViewRepo.findOperatorById(id);
-        return OperatorConverter.INSTANCE.fromEntityToDto(operator);
+        OperatorDto operatorDto = OperatorConverter.INSTANCE.fromEntityToDto(operator);
+        if (StringUtils.isNotBlank(operatorDto.getFileName())) {
+            String filePath = getExtractPath(getStem(operatorDto.getFileName()));
+            String requirements = filePath + "/requirements.txt";
+            operatorDto.setRequirements(readRequirements(requirements));
+            operatorDto.setReadme(getReadmeContent(filePath));
+        }
+        operatorDto.setFileName(null);
+        operatorDto.setReleases(operatorReleaseRepo.findAllByOperatorId(id));
+        return operatorDto;
     }
 
     @Transactional
     public OperatorDto createOperator(OperatorDto req) {
         overrideSettings(req);
         operatorRepo.insertOperator(req);
         relationRepo.batchInsert(req.getId(), req.getCategories());
+        if (CollectionUtils.isNotEmpty(req.getReleases())) {
+            OperatorReleaseDto release = req.getReleases().getFirst();
+            release.setId(req.getId());
+            release.setVersion(req.getVersion());
+            release.setReleaseDate(LocalDateTime.now());
+            operatorReleaseRepo.insertOperatorRelease(release);
+        }
         parserHolder.extractTo(getFileType(req.getFileName()), getUploadPath(req.getFileName()),
-                getExtractPath(getFileNameWithoutExtension(req.getFileName())));
+                getExtractPath(getStem(req.getFileName())));
         return getOperatorById(req.getId());
     }
 
     @Transactional
     public OperatorDto updateOperator(String id, OperatorDto req) {
+        OperatorDto operator = getOperatorById(id);
         overrideSettings(req);
         operatorRepo.updateOperator(req);
-        if (CollectionUtils.isNotEmpty(req.getCategories())) {
+        if (StringUtils.isNotBlank(req.getFileName()) && CollectionUtils.isNotEmpty(req.getCategories())) {
             relationRepo.batchUpdate(id, req.getCategories());
         }
+        if (CollectionUtils.isNotEmpty(req.getReleases())) {
+            OperatorReleaseDto release = req.getReleases().getFirst();
+            release.setId(req.getId());
+            release.setVersion(req.getVersion());
+            release.setReleaseDate(LocalDateTime.now());
+            if (StringUtils.equals(operator.getVersion(), req.getVersion())) {
+                operatorReleaseRepo.updateOperatorRelease(release);
+            } else {
+                operatorReleaseRepo.insertOperatorRelease(release);
+            }
+        }
         if (StringUtils.isNotBlank(req.getFileName())) {
             parserHolder.extractTo(getFileType(req.getFileName()), getUploadPath(req.getFileName()),
-                    getExtractPath(getFileNameWithoutExtension(req.getFileName())));
+                    getExtractPath(getStem(req.getFileName())));
         }
         return getOperatorById(id);
     }
@@ -98,8 +137,11 @@ public void deleteOperator(String id) {
         if (relationRepo.operatorIsPredefined(id)) {
             throw BusinessException.of(OperatorErrorCode.CANT_DELETE_PREDEFINED_OPERATOR);
         }
+        OperatorView operator = operatorViewRepo.findOperatorById(id);
         operatorRepo.deleteOperator(id);
         relationRepo.deleteByOperatorId(id);
+        operatorReleaseRepo.deleteOperatorRelease(id);
+        FileUtils.deleteQuietly(new File(getExtractPath(getStem(operator.getFileName()))));
     }
 
     public OperatorDto uploadOperator(String fileName) {
@@ -123,7 +165,7 @@ private String getFileType(String fileName) {
         return fileName.substring(fileName.lastIndexOf('.') + 1);
     }
 
-    private String getFileNameWithoutExtension(String fileName) {
+    private String getStem(String fileName) {
         return fileName.substring(0, fileName.lastIndexOf('.'));
     }
 
@@ -220,4 +262,44 @@ private void updateProperties(Map<String, Object> setting, Object value) {
             setting.put("properties", result);
         }
     }
+
+    private List<String> readRequirements(String filePath) {
+        Path path = Paths.get(filePath);
+        if (!Files.exists(path) || !Files.isRegularFile(path)) {
+            log.warn("requirements文件不存在或路径错误: {}", filePath);
+            return Collections.emptyList();
+        }
+
+        List<String> requirements = new ArrayList<>();
+        try (Stream<String> lines = Files.lines(path)) {
+            requirements = lines.map(String::trim)
+                    .filter(line -> !line.isEmpty())
+                    .filter(line -> !line.startsWith("#"))
+                    .collect(Collectors.toList());
+        } catch (IOException e) {
+            log.warn("读取requirements文件异常: {}", e.getMessage());
+        }
+        return requirements;
+    }
+
+    private String getReadmeContent(String directoryPath) {
+        Path dir = Paths.get(directoryPath);
+        if (!Files.exists(dir) || !Files.isDirectory(dir)) {
+            System.err.println("目录不存在: " + directoryPath);
+            return null;
+        }
+        List<String> candidateNames = Arrays.asList("README.md", "readme.md", "Readme.md");
+        for (String fileName : candidateNames) {
+            Path filePath = dir.resolve(fileName);
+            if (Files.exists(filePath) && Files.isRegularFile(filePath)) {
+                try {
+                    byte[] bytes = Files.readAllBytes(filePath);
+                    return new String(bytes, StandardCharsets.UTF_8);
+                } catch (IOException e) {
+                    log.warn("找到文件但读取失败: {}, 错误: {}", filePath, e.getMessage());
+                }
+            }
+        }
+        return "";
+    }
 }

backend/services/operator-market-service/src/main/java/com/datamate/operator/domain/model/Operator.java

@@ -28,6 +28,12 @@ public class Operator {
 
     private String fileName;
 
+    private Long fileSize;
+
+    private String metrics;
+
+    private Integer usageCount;
+
     private Boolean isStar;
 
     private LocalDateTime createdAt;

backend/services/operator-market-service/src/main/java/com/datamate/operator/domain/model/OperatorRelease.java

@@ -0,0 +1,24 @@
+package com.datamate.operator.domain.model;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.datamate.common.infrastructure.config.PgJsonTypeHandler;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Getter
+@Setter
+@TableName(value = "t_operator_release", autoResultMap = true)
+public class OperatorRelease {
+    private String id;
+
+    private String version;
+
+    private LocalDateTime releaseDate;
+
+    @TableField(typeHandler = PgJsonTypeHandler.class)
+    private List<String> changelog;
+}

backend/services/operator-market-service/src/main/java/com/datamate/operator/domain/model/OperatorView.java

@@ -31,6 +31,14 @@ public class OperatorView {
 
     private String settings;
 
+    private String fileName;
+
+    private Long fileSize;
+
+    private String metrics;
+
+    private Integer usageCount;
+
     private Boolean isStar;
 
     private LocalDateTime createdAt;

backend/services/operator-market-service/src/main/java/com/datamate/operator/domain/repository/OperatorReleaseRepository.java

@@ -0,0 +1,17 @@
+package com.datamate.operator.domain.repository;
+
+import com.baomidou.mybatisplus.extension.repository.IRepository;
+import com.datamate.operator.domain.model.OperatorRelease;
+import com.datamate.operator.interfaces.dto.OperatorReleaseDto;
+
+import java.util.List;
+
+public interface OperatorReleaseRepository extends IRepository<OperatorRelease> {
+    List<OperatorReleaseDto> findAllByOperatorId(String operatorId);
+
+    void insertOperatorRelease(OperatorReleaseDto operatorRelease);
+
+    void updateOperatorRelease(OperatorReleaseDto operatorRelease);
+
+    void deleteOperatorRelease(String operatorId);
+}

backend/services/operator-market-service/src/main/java/com/datamate/operator/domain/repository/OperatorRepository.java

@@ -18,4 +18,6 @@ public interface OperatorRepository extends IRepository<Operator> {
     int countOperatorByStar(boolean isStar);
 
     boolean operatorInTemplateOrRunning(String operatorId);
+
+    void incrementUsageCount(List<String> operatorIds);
 }

backend/services/operator-market-service/src/main/java/com/datamate/operator/infrastructure/converter/OperatorReleaseConverter.java

@@ -0,0 +1,17 @@
+package com.datamate.operator.infrastructure.converter;
+
+import com.datamate.operator.domain.model.OperatorRelease;
+import com.datamate.operator.interfaces.dto.OperatorReleaseDto;
+import org.mapstruct.Mapper;
+import org.mapstruct.factory.Mappers;
+
+import java.util.List;
+
+@Mapper
+public interface OperatorReleaseConverter {
+    OperatorReleaseConverter INSTANCE = Mappers.getMapper(OperatorReleaseConverter.class);
+
+    List<OperatorReleaseDto> fromEntityToDto(List<OperatorRelease> dto);
+
+    OperatorRelease fromDtoToEntity(OperatorReleaseDto dto);
+}

backend/services/operator-market-service/src/main/java/com/datamate/operator/infrastructure/parser/AbstractParser.java

@@ -5,6 +5,7 @@
 import com.datamate.operator.domain.contants.OperatorConstant;
 import com.datamate.operator.infrastructure.exception.OperatorErrorCode;
 import com.datamate.operator.interfaces.dto.OperatorDto;
+import com.datamate.operator.interfaces.dto.OperatorReleaseDto;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.yaml.snakeyaml.LoaderOptions;
@@ -13,10 +14,7 @@
 
 import java.io.File;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
+import java.util.*;
 
 public abstract class AbstractParser {
     protected ObjectMapper objectMapper = new ObjectMapper();
@@ -33,6 +31,15 @@ protected OperatorDto parseYaml(InputStream yamlContent) {
         operator.setOutputs(toStringIfNotNull(content.get("outputs")));
         operator.setRuntime(toJsonIfNotNull(content.get("runtime")));
         operator.setSettings(toJsonIfNotNull(content.get("settings")));
+        operator.setMetrics(toJsonIfNotNull(content.get("metrics")));
+        Object changelog = content.get("release");
+        OperatorReleaseDto operatorReleaseDto = new OperatorReleaseDto();
+        if (changelog instanceof List) {
+            operatorReleaseDto.setChangelog((List<String>) changelog);
+        } else {
+            operatorReleaseDto.setChangelog(Collections.emptyList());
+        }
+        operator.setReleases(List.of(operatorReleaseDto));
         List<String> categories = new ArrayList<>();
         categories.add(OperatorConstant.CATEGORY_MAP.get(toLowerCaseIfNotNull(content.get("language"))));
         categories.add(OperatorConstant.CATEGORY_MAP.get(toLowerCaseIfNotNull(content.get("modal"))));

backend/services/operator-market-service/src/main/java/com/datamate/operator/infrastructure/parser/ParserHolder.java

@@ -5,6 +5,7 @@
 import com.datamate.operator.infrastructure.exception.OperatorErrorCode;
 import com.datamate.operator.interfaces.dto.OperatorDto;
 import jakarta.annotation.PostConstruct;
+import org.apache.commons.io.FileUtils;
 import org.springframework.stereotype.Component;
 
 import java.io.File;
@@ -47,6 +48,7 @@ public void extractTo(String type, File archive, String targetDir) {
                 "No parser registered for type: " + type);
         }
         parser.extractTo(archive, targetDir);
+        FileUtils.deleteQuietly(archive);
     }
 
     public void extractTo(String type, String sourceDir, String targetDir) {

backend/services/operator-market-service/src/main/java/com/datamate/operator/infrastructure/persistence/Impl/OperatorReleaseRepositoryImpl.java

@@ -0,0 +1,46 @@
+package com.datamate.operator.infrastructure.persistence.Impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.repository.CrudRepository;
+import com.datamate.operator.domain.model.OperatorRelease;
+import com.datamate.operator.domain.repository.OperatorReleaseRepository;
+import com.datamate.operator.infrastructure.converter.OperatorReleaseConverter;
+
+import com.datamate.operator.infrastructure.persistence.mapper.OperatorReleaseMapper;
+import com.datamate.operator.interfaces.dto.OperatorReleaseDto;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+@RequiredArgsConstructor
+public class OperatorReleaseRepositoryImpl extends CrudRepository<OperatorReleaseMapper, OperatorRelease> implements OperatorReleaseRepository {
+    private final OperatorReleaseMapper mapper;
+
+    public List<OperatorReleaseDto> findAllByOperatorId(String operatorId) {
+        QueryWrapper<OperatorRelease> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("id", operatorId)
+                .orderByDesc("release_date");
+        return OperatorReleaseConverter.INSTANCE.fromEntityToDto(mapper.selectList(queryWrapper));
+    }
+
+    @Override
+    public void insertOperatorRelease(OperatorReleaseDto operatorReleaseDto) {
+        mapper.insert(OperatorReleaseConverter.INSTANCE.fromDtoToEntity(operatorReleaseDto));
+    }
+
+    @Override
+    public void updateOperatorRelease(OperatorReleaseDto operatorReleaseDto) {
+        QueryWrapper<OperatorRelease> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("id", operatorReleaseDto.getId())
+                .eq("version", operatorReleaseDto.getVersion());
+        mapper.update(OperatorReleaseConverter.INSTANCE.fromDtoToEntity(operatorReleaseDto), queryWrapper);
+    }
+
+    @Override
+    public void deleteOperatorRelease(String operatorId) {
+        mapper.delete(new QueryWrapper<OperatorRelease>().eq("id", operatorId));
+    }
+
+}