NWPU-IPS/ips-admin/src/main/java/com/ips/system/service/impl/BizTrainingServiceImpl.java

package com.ips.system.service.impl;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ips.common.utils.DateUtils;
import com.ips.common.utils.StringUtils;
import com.ips.system.domain.AlgorithmConfig;
import com.ips.system.domain.Distillation;
import com.ips.system.dto.AlgorithmParamsDto;
import com.ips.system.service.IAlgorithmConfigService;
import com.ips.system.utils.AlgorithmCaller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ips.system.mapper.BizTrainingMapper;
import com.ips.system.domain.BizTraining;
import com.ips.system.service.IBizTrainingService;

/**
 * 模型训练Service业务层处理
 *
 * @author Allen
 * @date 2025-05-21
 */
@Service
public class BizTrainingServiceImpl implements IBizTrainingService {

    protected final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private BizTrainingMapper bizTrainingMapper;

    @Autowired
    private IAlgorithmConfigService algorithmConfigService;

    /**
     * 查询模型训练
     *
     * @param id 模型训练主键
     * @return 模型训练
     */
    @Override
    public BizTraining selectBizTrainingById(Long id) {
        return bizTrainingMapper.selectBizTrainingById(id);
    }

    /**
     * 查询模型训练列表
     *
     * @param bizTraining 模型训练
     * @return 模型训练
     */
    @Override
    public List<BizTraining> selectBizTrainingList(BizTraining bizTraining) {
        return bizTrainingMapper.selectBizTrainingList(bizTraining);
    }

    /**
     * 新增模型训练
     *
     * @param bizTraining 模型训练
     * @return 结果
     */
    @Override
    public int insertBizTraining(BizTraining bizTraining) {
        bizTraining.setCreateTime(DateUtils.getNowDate());
        return bizTrainingMapper.insertBizTraining(bizTraining);
    }

    /**
     * 修改模型训练
     *
     * @param bizTraining 模型训练
     * @return 结果
     */
    @Override
    public int updateBizTraining(BizTraining bizTraining) {
        bizTraining.setUpdateTime(DateUtils.getNowDate());
        return bizTrainingMapper.updateBizTraining(bizTraining);
    }

    /**
     * 批量删除模型训练
     *
     * @param ids 需要删除的模型训练主键
     * @return 结果
     */
    @Override
    public int deleteBizTrainingByIds(Long[] ids) {
        return bizTrainingMapper.deleteBizTrainingByIds(ids);
    }

    /**
     * 删除模型训练信息
     *
     * @param id 模型训练主键
     * @return 结果
     */
    @Override
    public int deleteBizTrainingById(Long id) {
        return bizTrainingMapper.deleteBizTrainingById(id);
    }

    @Override
    public String run(Long id) throws JsonProcessingException {
        BizTraining training = bizTrainingMapper.selectBizTrainingById(id);
        if (training == null || training.getAlgorithmId() == null) {
            return "无法找到该任务,id:" + id;
        }
        Long algorithmId = training.getAlgorithmId();
        AlgorithmConfig algorithmConfig = algorithmConfigService.selectAlgorithmConfigById(algorithmId);
        training.setStartTime(new Date());
        training.setStatus("1");
        this.updateBizTraining(training);
        CompletableFuture.runAsync(() -> {
            // 异步逻辑
            doRun(algorithmConfig, training);
        });
        return null;
    }

    private void doRun(AlgorithmConfig algorithmConfig, BizTraining training) {
        String algorithmPath = algorithmConfig.getAlgorithmPath();

        // 组装json
        String inputPath = training.getInputPath();
        String outputPath = training.getOutputPath();
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, Object> params = new HashMap<>(0);

        String errorMsg = "";
        try {
            if (StringUtils.isNotEmpty(training.getAlgorithmParams())) {

                objectMapper.readValue(
                        training.getAlgorithmParams(),
                        new TypeReference<Map<String, Object>>() {
                        }
                );
            }
            AlgorithmParamsDto algorithmParamsDto = new AlgorithmParamsDto(inputPath, outputPath, params);
            // 对象 → JSON 字符串
            String json = objectMapper.writeValueAsString(algorithmParamsDto);
            // 处理算法
            errorMsg = AlgorithmCaller.executeAlgorithm(algorithmPath, json);
        } catch (JsonProcessingException e) {
            logger.error("格式化失败", e);
            errorMsg = "格式化失败";
        }
        //处理结果
        if (StringUtils.isEmpty(errorMsg)) {
            training.setStatus("2");
        } else {
            training.setStatus("3");
        }
        training.setEndTime(new Date());
        this.updateBizTraining(training);
    }

    @Override
    public BizTraining getResultDetails(Long id) {
        BizTraining bizTraining = this.selectBizTrainingById(id);
        String inputPath = bizTraining.getInputPath();
//        try {
//            List<FileInfoDTO> fileInfoDTOList = CommonUtils.getSortedFiles(inputPath, "dat");
//            extractedFeatures.setFolderInfoDTO(fileInfoDTOList);
//        } catch (IOException e) {
//            logger.error("读取文件夹错误", e);
//            return null;
//        }
        return bizTraining;
    }
}