你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.baomidou.mybatisplus.plugins下的类Page中有一个名为toString的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String toString() {
    StringBuilder pg = new StringBuilder();
    pg.append(" Page:{ [").append(super.toString()).append("], ");
    if (records != null) {
        pg.append("records-size:").append(records.size());
    } else {
        pg.append("records is null");
    }
    return pg.append(" }").toString();
}
### 类导入的包

### 类级别的变量
/**
 * 查询数据列表
 */
//    @JsonProperty("list")
private List<T> records = Collections.emptyList();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.baomidou.mybatisplus.plugins.handlers下的类JacksonTypeHandler中有一个名为setNonNullParameter的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
    try {
        ps.setString(i, objectMapper.writeValueAsString(parameter));
    } catch (JsonProcessingException e) {
        throw new RuntimeException(e);
    }
}
### 类导入的包
com.fasterxml.jackson.core.JsonProcessingException
### 类级别的变量
private static final ObjectMapper objectMapper = new ObjectMapper();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.baomidou.mybatisplus.plugins.handlers下的类JacksonTypeHandler中有一个名为parse的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private T parse(String json) {
    try {
        return json == null ? null : objectMapper.readValue(json, type);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
### 类导入的包
java.io.IOException
### 类级别的变量
private static final ObjectMapper objectMapper = new ObjectMapper();
private Class<T> type;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.baomidou.mybatisplus.plugins.pagination下的类Pagination中有一个名为getPages的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public int getPages() {
    if (this.size == 0) {
        return 0;
    }
    this.pages = this.total / this.size;
    if (this.total % this.size != 0) {
        this.pages++;
    }
    return this.pages;
}
### 类导入的包

### 类级别的变量
/**
 * 总数
 */
private int total;
/**
 * 每页显示条数，默认 10
 */
//    @JsonProperty("pageSize")
private int size = 10;
/**
 * 总页数
 */
private int pages;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.baomidou.mybatisplus.plugins.pagination下的类Pagination中有一个名为orders的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private List<String> orders(boolean condition, List<String> columns) {
    if (condition && StringUtils.isNotEmpty(orderByField)) {
        if (columns == null) {
            columns = new ArrayList<>();
        }
        if (!columns.contains(orderByField)) {
            columns.add(orderByField);
        }
    }
    return columns;
}
### 类导入的包
com.baomidou.mybatisplus.toolkit.StringUtils
java.util.ArrayList
java.util.List
### 类级别的变量
/**
 * <p>
 * SQL 排序 ORDER BY 字段，例如： id DESC（根据id倒序查询）
 * </p>
 * <p>
 * DESC 表示按倒序排序(即：从大到小排序)<br>
 * ASC 表示按正序排序(即：从小到大排序)
 *
 * @see #ascs
 * @see #descs
 * </p>
 */
private String orderByField;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.aspect下的类UsageCountAspect中有一个名为around的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    Object result = null;
    result = joinPoint.proceed();
    try {
        // 获取方法信息
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取方法名
        String methodName = signature.getName();
        //获取类名
        String clzName = signature.getDeclaringType().getName();
        // 获取方法参数名
        String[] paramNames = signature.getParameterNames();
        // 获取方法参数值
        Object[] args = joinPoint.getArgs();
        // 获取注解信息
        UsageCount usageCount = signature.getMethod().getAnnotation(UsageCount.class);
        String field;
        field = parseKey(usageCount.field(), paramNames, args);
        String[] keys = usageCount.type();
        if (keys != null && keys.length > 0) {
            Arrays.stream(keys).forEach(key -> {
                if (StringUtils.isNotEmpty(key)) {
                    redisUtils.hincr(key, field, 1L);
                }
            });
        } else {
            String key = clzName + "." + methodName;
            redisUtils.hincr(key, field, 1L);
        }
        return result;
    } catch (Throwable throwable) {
        log.error("UsageCountAspect around advice error", throwable.getMessage());
        return result;
    }
}
### 类导入的包
org.apache.commons.lang3.StringUtils
org.aspectj.lang.annotation.Aspect
org.aspectj.lang.reflect.MethodSignature
java.util.Arrays
### 类级别的变量
@Autowired
private RedisUtils redisUtils;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.aspect下的类UsageCountAspect中有一个名为parseKey的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取缓存的key
     * key 定义在注解上，支持SPEL表达式
     *
     * @return
     */
private String parseKey(String key, String[] paramNames, Object[] args) {
    if (StringUtils.isEmpty(key)) {
        return null;
    }
    //使用SPEL进行key的解析
    ExpressionParser parser = new SpelExpressionParser();
    //SPEL上下文
    StandardEvaluationContext context = new StandardEvaluationContext();
    //把方法参数放入SPEL上下文中
    for (int i = 0; i < paramNames.length; i++) {
        context.setVariable(paramNames[i], args[i]);
    }
    return parser.parseExpression(key).getValue(context, String.class);
}
### 类导入的包
org.apache.commons.lang3.StringUtils
org.springframework.expression.ExpressionParser
org.springframework.expression.spel.standard.SpelExpressionParser
org.springframework.expression.spel.support.StandardEvaluationContext
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.aspect下的类UserCountAspect中有一个名为around的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    //返回值
    Object result = null;
    result = joinPoint.proceed();
    try {
        // 获取方法信息
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取方法名
        String methodName = signature.getName();
        //获取类名
        String clzName = signature.getDeclaringType().getName();
        // 获取注解信息
        UserCount userCount = signature.getMethod().getAnnotation(UserCount.class);
        HttpServletRequest request = ServletRequestAttributes.class.cast(RequestContextHolder.currentRequestAttributes()).getRequest();
        User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
        if (user != null) {
            String[] keys = userCount.type();
            if (keys != null && keys.length > 0) {
                Arrays.stream(keys).forEach(key -> {
                    if (StringUtils.isNotEmpty(key)) {
                        redisUtils.sSet(key, String.valueOf(user.getId()));
                    }
                });
            } else {
                String key = clzName + "." + methodName;
                redisUtils.sSet(key, String.valueOf(user.getId()));
            }
        }
        return result;
    } catch (Throwable throwable) {
        log.error("UserCountAspect around advice error", throwable.getMessage());
        return result;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.utils.SessionUtils
org.apache.commons.lang3.StringUtils
org.aspectj.lang.annotation.Aspect
org.aspectj.lang.reflect.MethodSignature
org.springframework.web.context.request.RequestContextHolder
org.springframework.web.context.request.ServletRequestAttributes
javax.servlet.http.HttpServletRequest
java.util.Arrays
### 类级别的变量
@Autowired
private RedisUtils redisUtils;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类AsycnConfig中有一个名为devModelAsyncExecutor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Executor devModelAsyncExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    //核心线程数
    taskExecutor.setCorePoolSize(10);
    //是否允许核心线程空闲退出
    taskExecutor.setAllowCoreThreadTimeOut(true);
    //最大线程数
    taskExecutor.setMaxPoolSize(20);
    //超时时间
    taskExecutor.setKeepAliveSeconds(60 * 30);
    //配置队列大小
    taskExecutor.setQueueCapacity(80);
    //配置线程池前缀
    taskExecutor.setThreadNamePrefix("dev-model-");
    //拒绝策略
    taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
    taskExecutor.initialize();
    return taskExecutor;
}
### 类导入的包
org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
java.util.concurrent.Executor
java.util.concurrent.ThreadPoolExecutor
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类AsycnConfig中有一个名为trainingModelAsyncExecutor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Executor trainingModelAsyncExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    //核心线程数
    taskExecutor.setCorePoolSize(10);
    //是否允许核心线程空闲退出
    taskExecutor.setAllowCoreThreadTimeOut(true);
    //最大线程数
    taskExecutor.setMaxPoolSize(20);
    //超时时间
    taskExecutor.setKeepAliveSeconds(60 * 30);
    //配置队列大小
    taskExecutor.setQueueCapacity(80);
    //配置线程池前缀
    taskExecutor.setThreadNamePrefix("training-model-");
    //拒绝策略
    taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
    taskExecutor.initialize();
    return taskExecutor;
}
### 类导入的包
org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
java.util.concurrent.Executor
java.util.concurrent.ThreadPoolExecutor
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类AsycnConfig中有一个名为deployModelAsyncExecutor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Executor deployModelAsyncExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    //核心线程数
    taskExecutor.setCorePoolSize(10);
    //是否允许核心线程空闲退出
    taskExecutor.setAllowCoreThreadTimeOut(true);
    //最大线程数
    taskExecutor.setMaxPoolSize(20);
    //超时时间
    taskExecutor.setKeepAliveSeconds(60 * 30);
    //配置队列大小
    taskExecutor.setQueueCapacity(80);
    //配置线程池前缀
    taskExecutor.setThreadNamePrefix("deploy-model-");
    //拒绝策略
    taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
    taskExecutor.initialize();
    return taskExecutor;
}
### 类导入的包
org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
java.util.concurrent.Executor
java.util.concurrent.ThreadPoolExecutor
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类AsycnConfig中有一个名为autoTrainingModelAsyncExecutor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Executor autoTrainingModelAsyncExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    //核心线程数
    taskExecutor.setCorePoolSize(10);
    //是否允许核心线程空闲退出
    taskExecutor.setAllowCoreThreadTimeOut(true);
    //最大线程数
    taskExecutor.setMaxPoolSize(20);
    //超时时间
    taskExecutor.setKeepAliveSeconds(60 * 30);
    //配置队列大小
    taskExecutor.setQueueCapacity(80);
    //配置线程池前缀
    taskExecutor.setThreadNamePrefix("auto-training-model-");
    //拒绝策略
    taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
    taskExecutor.initialize();
    return taskExecutor;
}
### 类导入的包
org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
java.util.concurrent.Executor
java.util.concurrent.ThreadPoolExecutor
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类AsycnConfig中有一个名为uploadFileAsyncExecutor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Executor uploadFileAsyncExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    //核心线程数
    taskExecutor.setCorePoolSize(10);
    //是否允许核心线程空闲退出
    taskExecutor.setAllowCoreThreadTimeOut(true);
    //最大线程数
    taskExecutor.setMaxPoolSize(20);
    //超时时间
    taskExecutor.setKeepAliveSeconds(60 * 30);
    //配置队列大小
    taskExecutor.setQueueCapacity(80);
    //配置线程池前缀
    taskExecutor.setThreadNamePrefix("upload-File-");
    //拒绝策略
    taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
    taskExecutor.initialize();
    return taskExecutor;
}
### 类导入的包
org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
java.util.concurrent.Executor
java.util.concurrent.ThreadPoolExecutor
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类KubernetesConfig中有一个名为kubernetesClient的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ApiClient kubernetesClient() {
    log.info("KubernetesConfig 初始化开始..........");
    //获取config
    ApiClient apiClient = null;
    Reader reader = null;
    try {
        Resource resource = new ClassPathResource("config_new");
        reader = new InputStreamReader(resource.getInputStream());
        //加载k8s, config
        apiClient = ClientBuilder.kubeconfig(KubeConfig.loadKubeConfig(reader)).build();
        //将加载config的client设置为默认的client
        io.kubernetes.client.openapi.Configuration.setDefaultApiClient(apiClient);
        log.info("KubernetesConfig 初始化成功..........");
    } catch (Exception e) {
        log.info("KubernetesConfig 初始化异常..........");
        e.printStackTrace();
    } finally {
        IOUtils.closeQuietly(reader);
    }
    return apiClient;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.util.ClientBuilder
io.kubernetes.client.util.KubeConfig
org.apache.commons.io.IOUtils
org.springframework.context.annotation.Configuration
org.springframework.core.io.ClassPathResource
org.springframework.core.io.Resource
java.io.InputStreamReader
java.io.Reader
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类RedisConfiguration中有一个名为redisTemplate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RedisTemplate<String, Object> redisTemplate() {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new StringRedisSerializer());
    redisTemplate.setConnectionFactory(factory);
    return redisTemplate;
}
### 类导入的包
org.springframework.data.redis.serializer.StringRedisSerializer
### 类级别的变量
@Autowired
private RedisConnectionFactory factory;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.config下的类WebTermSocketConfig中有一个名为registerWebSocketHandlers的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    // 接收 "/webterm" 请求
    registry.addHandler(webSocketHandler(), "/webterm").setAllowedOrigins("*");
    // 接收 "/K8WebTerminal" 请求
    registry.addHandler(shellWebSocketHandler(), "/K8WebTerminal").setAllowedOrigins("*");
}
### 类导入的包
org.springframework.web.socket.WebSocketHandler
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiDatasetController中有一个名为queryList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<UiPage<GdaiDatasetVo>> queryList(@RequestBody GdaiDatasetVo gdaiDatasetVo) {
    log.info("GdaiDatasetController.queryList params: " + JSON.toJSONString(gdaiDatasetVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    List<String> desc = new ArrayList<>();
    desc.add("dataset_id");
    List<GdaiDatasetVo> list = new ArrayList<>();
    GdaiDatasetVo datasetVo;
    EntityWrapper<GdaiDataset> wrapper = new EntityWrapper<GdaiDataset>();
    //tbd 数据集查看共享处理
    //        if (!CommonTools.isSuperAdminOrAiGroupAdmin(user)) {
    //            wrapper.eq("creator_id", userId);
    //        }
    wrapper.eq(gdaiDatasetVo.getDataType() != null, "data_type", gdaiDatasetVo.getDataType()).like("dataset_name", gdaiDatasetVo.getDatasetName()).orderDesc(desc);
    Page<GdaiDataset> gdaiDatasetPage = gdaiDatasetService.selectPage(new Page<>(gdaiDatasetVo.getPageNumber(), gdaiDatasetVo.getPageCount()), wrapper);
    if ("PIC".equals(gdaiDatasetVo.getDataType())) {
        if (gdaiDatasetPage != null && gdaiDatasetPage.getRecords().size() > 0) {
            List<GdaiDataset> records = gdaiDatasetPage.getRecords();
            for (GdaiDataset dataset : records) {
                Long datasetId = dataset.getDatasetId();
                //查询该数据集下所有文件个数（数据总量）
                Integer fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId));
                //查询已标注的文件个数并计算百分比
                Integer hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(datasetId);
                String percentage = CalculateUtils.percentInstance(hasFlagCount, fileCount, 2);
                datasetVo = new GdaiDatasetVo();
                BeanUtils.copyProperties(dataset, datasetVo);
                datasetVo.setFileCount(fileCount);
                datasetVo.setHasFlagCount(hasFlagCount);
                datasetVo.setPercentage(percentage);
                list.add(datasetVo);
            }
        }
    } else if ("TXT".equals(gdaiDatasetVo.getDataType())) {
        if (gdaiDatasetPage != null && gdaiDatasetPage.getRecords().size() > 0) {
            List<GdaiDataset> records = gdaiDatasetPage.getRecords();
            for (GdaiDataset dataset : records) {
                Long datasetId = dataset.getDatasetId();
                //查询该数据集下所有文本文件个数（数据总量）
                Integer fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId));
                //查询已标注的文件个数并计算百分比
                Integer hasFlagCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId).eq("mark_status", "1"));
                String percentage = CalculateUtils.percentInstance(hasFlagCount, fileCount, 2);
                datasetVo = new GdaiDatasetVo();
                BeanUtils.copyProperties(dataset, datasetVo);
                datasetVo.setFileCount(fileCount);
                datasetVo.setHasFlagCount(hasFlagCount);
                datasetVo.setPercentage(percentage);
                list.add(datasetVo);
            }
        }
    } else {
        return RestResult.genFailResult("数据集类型错误");
    }
    UiPage<GdaiDatasetVo> uiPage = new UiPage<>();
    uiPage.setTotal(gdaiDatasetPage.getTotal());
    uiPage.setPageSize(gdaiDatasetPage.getSize());
    uiPage.setPages(gdaiDatasetPage.getPages());
    uiPage.setPageNum(gdaiDatasetPage.getCurrent());
    uiPage.setList(list);
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.util.CalculateUtils
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.springframework.beans.BeanUtils
java.util.ArrayList
java.util.List
### 类级别的变量
@Autowired
private GdaiDatasetService gdaiDatasetService;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiDifyController中有一个名为createAccount的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult createAccount(@RequestBody JSONObject body) throws Exception {
    //        {
    //            "email": "v-csilian.gd@chinatelecom.cn",
    //            "name": "v-csilian",
    //            "password":"q1w2e3R$"
    //        }
    return difyService.createAccount(body);
}
### 类导入的包

### 类级别的变量
@Resource
private DifyService difyService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiDifyController中有一个名为deleteAccount的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteAccount(@RequestBody JSONObject body) throws Exception {
    //        {
    //            "email": "v-csilian.gd@chinatelecom.cn"
    //        }
    return difyService.deleteAccount(body);
}
### 类导入的包

### 类级别的变量
@Resource
private DifyService difyService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiDifyController中有一个名为createTenant的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult createTenant(@RequestBody JSONObject body) throws Exception {
    //        {
    //            "tenantName": "AI项目测试"
    //        }
    return difyService.createTenant(body);
}
### 类导入的包

### 类级别的变量
@Resource
private DifyService difyService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiDifyController中有一个名为createTenantMember的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult createTenantMember(@RequestBody JSONObject body) throws Exception {
    //        {
    //            "tenantName": "AI项目测试",
    //            "email": "v-chensl.gd@chinatelecom.cn",
    //            "name": "v-chensl",
    //            "role": "admin" //owner admin editor normal
    //        }
    return difyService.createTenantMember(body);
}
### 类导入的包

### 类级别的变量
@Resource
private DifyService difyService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiDifyController中有一个名为listMembers的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult listMembers(@RequestBody JSONObject body) throws Exception {
    //        {
    //            "tenantName": "gdai-14"
    //        }
    return difyService.listMembers(body);
}
### 类导入的包

### 类级别的变量
@Resource
private DifyService difyService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为queryList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<UiPage<GdaiImage>> queryList(@RequestBody GdaiImagePageQuery gdaiImagePageQuery) {
    log.info("GdaiImageController.queryList params: [{}]", JSON.toJSONString(gdaiImagePageQuery));
    List<String> desc = new ArrayList<>();
    desc.add("image_id");
    Page<GdaiImage> gdaiImagePage = gdaiImageService.selectPage(new Page<>(gdaiImagePageQuery.getPageNum(), gdaiImagePageQuery.getPageSize()), new EntityWrapper<GdaiImage>().like("image_name", gdaiImagePageQuery.getImageName()).orderDesc(desc));
    UiPage<GdaiImage> uiPage = ReturnJson.turnUiPage(gdaiImagePage);
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiImage
com.eshore.gdai.trainingcenter.util.ReturnJson
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiImageService gdaiImageService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为queryListNoPage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryListNoPage(@RequestBody GdaiImage gdaiImage) {
    log.info("GdaiImageController.queryListNoPage params: [{}]", JSON.toJSONString(gdaiImage));
    List<String> desc = new ArrayList<>();
    desc.add("image_id");
    List<GdaiImageVo> imageList = new ArrayList<>();
    GdaiImageVo gdaiImageVo;
    List<GdaiImage> gdaiImages = gdaiImageService.selectList(new EntityWrapper<GdaiImage>().orderDesc(desc));
    if (gdaiImages != null && gdaiImages.size() > 0) {
        for (GdaiImage image : gdaiImages) {
            gdaiImageVo = new GdaiImageVo();
            BeanUtils.copyProperties(image, gdaiImageVo);
            String imageName = image.getImageName();
            if (StringUtils.isNotBlank(imageName)) {
                List<GdaiImage> images = gdaiImageService.selectList(new EntityWrapper<GdaiImage>().eq("image_name", imageName).orderDesc(desc));
                gdaiImageVo.setList(images);
            }
            imageList.add(gdaiImageVo);
        }
    }
    return RestResult.genSuccessResult(imageList);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiImage
com.eshore.gdai.trainingcenter.vo.GdaiImageVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiImageService gdaiImageService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Long> add(@RequestBody GdaiImage gdaiImage) {
    log.info("GdaiImageController.add params: [{}]", JSON.toJSONString(gdaiImage));
    if (StringUtils.isBlank(gdaiImage.getImageName())) {
        return RestResult.genFailResult("机器学习框架镜像名称不能为空");
    }
    if (StringUtils.isBlank(gdaiImage.getFramework())) {
        return RestResult.genFailResult("机器学习框架不能为空");
    }
    if (StringUtils.isBlank(gdaiImage.getProcessUnitType())) {
        return RestResult.genFailResult("处理器类型不能为空");
    }
    if (StringUtils.isBlank(gdaiImage.getImageTag())) {
        return RestResult.genFailResult("机器学习框架镜像版本不能为空");
    }
    try {
        // 根据模型名称查询是否存在相同名称模型
        List<GdaiImage> GdaiImageList = gdaiImageService.selectList(new EntityWrapper<GdaiImage>().eq("image_name", gdaiImage.getImageName()).eq("image_tag", gdaiImage.getImageTag()));
        if (GdaiImageList != null && GdaiImageList.size() > 0) {
            return RestResult.genFailResult("已存在同名机器学习框架");
        }
        Date curDate = new Date();
        gdaiImage.setCreateTime(curDate);
        gdaiImage.setModifyTime(curDate);
        gdaiImageService.insert(gdaiImage);
    } catch (Exception e) {
        log.info("新增模型异常", e);
        return RestResult.genFailResult("新增模型异常");
    }
    return RestResult.genSuccessResult(gdaiImage.getImageId());
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiImage
org.apache.commons.lang3.StringUtils
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiImageService gdaiImageService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Boolean> update(@RequestBody GdaiImage gdaiImage) throws DcoosException {
    if (gdaiImage.getImageId() == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    if (StringUtils.isBlank(gdaiImage.getImageName())) {
        return RestResult.genFailResult("机器学习框架名称不能为空");
    }
    if (StringUtils.isBlank(gdaiImage.getFramework())) {
        return RestResult.genFailResult("机器学习框架不能为空");
    }
    if (StringUtils.isBlank(gdaiImage.getProcessUnitType())) {
        return RestResult.genFailResult("处理器类型不能为空");
    }
    if (StringUtils.isBlank(gdaiImage.getImageTag())) {
        return RestResult.genFailResult("机器学习框架镜像版本不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        checkGdaiImage(user, gdaiImage.getImageId());
        //            GdaiImage image = gdaiImageService.selectById(gdaiImage.getImageId());
        //            if (image == null) {
        //                return RestResult.genFailResult("该机器学习框架不存在");
        //            }
        Date curDate = new Date();
        gdaiImage.setModifyTime(curDate);
        boolean result = gdaiImageService.updateById(gdaiImage);
        return RestResult.genSuccessResult(result);
    } catch (Exception e) {
        e.printStackTrace();
        throw new DcoosException(ExceptionMeta.DCOOS_DATA_NOT_EXIST);
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.DcoosException
com.chinatelecom.dcoos.common.exception.ExceptionMeta
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiImage
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiImageService gdaiImageService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Boolean> delete(@PathVariable("id") Long id) throws TrainginCenterException {
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    checkGdaiImage(user, id);
    boolean result = gdaiImageService.deleteById(id);
    return RestResult.genSuccessResult(result);
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiImage
### 类级别的变量
@Resource
private GdaiImageService gdaiImageService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<GdaiImage> get(@PathVariable("id") Long id) throws DcoosException {
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiImage gdaiImage = checkGdaiImage(user, id);
    //        GdaiImage gdaiImage = gdaiImageService.selectById(id);
    return RestResult.genSuccessResult(gdaiImage);
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiImage
### 类级别的变量
@Resource
private GdaiImageService gdaiImageService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为checkImage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult checkImage(@RequestBody YamlVo yamlVo) throws Exception {
    try {
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        Class<?> yamClz = classLoader.loadClass(yamlVo.getYamlClz());
        Class<?> modelClz = classLoader.loadClass(yamlVo.getModelClz());
        Object model = JSON.parseObject(yamlVo.getModel().toJSONString(), modelClz);
        Object object = YamlUtil.loadObject(yamlVo.getYamlContent(), model, yamClz);
        String result = io.kubernetes.client.util.Yaml.dump(object);
        log.info(result);
        return RestResult.genSuccessResult(result);
    } catch (Exception e) {
        return RestResult.genFailResult(e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.util.YamlUtil
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiImageController中有一个名为checkGdaiImage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiImage checkGdaiImage(User user, Long autoManageId) throws TrainginCenterException {
    GdaiImage gdaiImage = gdaiImageMapper.selectById(autoManageId);
    if (gdaiImage == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色(超级管理员角色)
        boolean aiGroupAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是管理员
        if (!aiGroupAdminRole) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiImage.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return gdaiImage;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiImage
### 类级别的变量
@Resource
private GdaiImageMapper gdaiImageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiInterfaceController中有一个名为calllback的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult calllback(@RequestBody JSONObject json) {
    if (json != null) {
        log.error("云网管通知信息：{}", JSONObject.toJSONString(json));
        return RestResult.genSuccessResult("suuccess");
    }
    return RestResult.genFailResult("不能为空");
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.result.RestResult
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiModelDeployController中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(@RequestBody GdaiModelDeployVo gdaiModelDeployVo) throws TrainginCenterException {
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long projectId = gdaiModelDeployVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long deployId = gdaiModelDeployVo.getDeployId();
    if (deployId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    //修复水平越权问题
    GdaiModelDeploy modelDeploy = checkGdaiModelDeploy(user, deployId, false);
    //判断用户是否是超级管理员,如果是超管则直接删除,如果不是超管,删除之前判断当前用户是否和创建人一致（该条记录的创建者才有删除权限）
    Boolean superAdminRole = CommonTools.checkDeletePermission(request, userId, modelDeploy.getCreatorId());
    if (!superAdminRole) {
        return RestResult.genFailResult("非创建者不能删除该记录");
    }
    return gdaiModelDeployService.delete(gdaiModelDeployVo);
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util.CommonTools
### 类级别的变量
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiModelDeployController中有一个名为checkGdaiModelDeploy的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 查询 修改 true   删除 false
     *
     * @param user
     * @param gdaiModelDeployId
     * @param isCheckShareFlag
     * @return
     * @throws TrainginCenterException
     */
 GdaiModelDeploy checkGdaiModelDeploy(User user, Long gdaiModelDeployId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectById(gdaiModelDeployId);
    if (gdaiModelDeploy == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiModelDeploy.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiModelDeploy.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiModelDeploy.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiModelDeploy;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
java.util.Set
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiModelServingController中有一个名为replace的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult replace(@RequestBody GdaiModelServingAddVo gdaiModelServingAddVo) throws TrainginCenterException {
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long gdaiModelServingId = gdaiModelServingAddVo.getServingId();
    if (gdaiModelServingId == null) {
        return RestResult.genFailResult("部署服务ID不能为空");
    }
    //修复水平越权问题
    GdaiModelServing gdaiModelServing = checkGdaiModelServing(user, gdaiModelServingId, true);
    return gdaiModelServingService.replace(gdaiModelServingAddVo);
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
### 类级别的变量
@Resource
private GdaiModelServingService gdaiModelServingService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiModelServingController中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(@RequestBody GdaiModelServingVo gdaiModelServingVo) throws TrainginCenterException {
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long projectId = gdaiModelServingVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long servingId = gdaiModelServingVo.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    //修复水平越权问题
    GdaiModelServing gdaiModelServing = checkGdaiModelServing(user, servingId, false);
    return gdaiModelServingService.delete(gdaiModelServingVo);
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
### 类级别的变量
@Resource
private GdaiModelServingService gdaiModelServingService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiModelServingController中有一个名为checkGdaiModelServing的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 查询 修改 true   删除 false
     *
     * @param user
     * @param gdaiModelServingId
     * @param isCheckShareFlag
     * @return
     * @throws TrainginCenterException
     */
 GdaiModelServing checkGdaiModelServing(User user, Long gdaiModelServingId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiModelServing gdaiModelServing = gdaiModelServingMapper.selectById(gdaiModelServingId);
    if (gdaiModelServing == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiModelServing.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiModelServing.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiModelServing.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiModelServing;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
java.util.Set
### 类级别的变量
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.controller下的类GdaiStatisticsController中有一个名为save的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult save() throws Exception {
    //查所有project
    List<GdaiProject> projects = projectService.selectList(new EntityWrapper<>());
    List<GdaiStatisticsVo> gdaiStatisticsVo = new ArrayList<>();
    for (GdaiProject project : projects) {
        //从redis查出对应的指标
        RestResult<JSONObject> result = statisticsService.getStatistics(project.getProjectId());
        if (result.getSuccess() == 0 && result.getData() != null && !result.getData().isEmpty()) {
            JSONObject statisic = result.getData();
            for (String key : statisic.keySet()) {
                GdaiStatisticsVo vo = new GdaiStatisticsVo();
                vo.setProjectId(project.getProjectId());
                vo.setMetricsType(key);
                vo.setMetricsValue(statisic.getString(key));
                gdaiStatisticsVo.add(vo);
            }
        }
    }
    //frameworkUser
    RestResult<JSONObject> result = statisticsService.getFrameworkUser();
    if (result.getSuccess() == 0 && result.getData() != null && !result.getData().isEmpty()) {
        GdaiStatisticsVo vo = new GdaiStatisticsVo();
        //            vo.setProjectId(project.getProjectId());
        vo.setMetricsType("frameworkUser");
        vo.setMetricsValue(result.getData().getString("frameworkUser"));
        gdaiStatisticsVo.add(vo);
    }
    //保存指标
    if (!gdaiStatisticsVo.isEmpty()) {
        gdaiStatisticsMapper.deleteStatistic();
        statisticsService.addBatch(gdaiStatisticsVo);
    }
    return RestResult.genSuccessResult("");
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.vo.GdaiStatisticsVo
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiStatisticsService statisticsService;
@Resource
private GdaiStatisticsMapper gdaiStatisticsMapper;
@Resource
private GdaiProjectService projectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.entity下的类GdaiDevModel中有一个名为buildContext的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildContext() throws Exception {
    JSONObject contextObj = JSON.parseObject(context);
    String bizName = "dev-model-" + devId;
    //name
    contextObj.put("name", bizName);
    contextObj.put("bizType", "dev_model");
    contextObj.put("bizEnv", LabelUtils.getBizEnvLabelStr());
    contextObj.put("bizId", String.valueOf(devId));
    //root 用户启动
    contextObj.put("user", "0");
    //nohup jupyter lab /usr/src/app
    contextObj.put("command", "nohup jupyter lab  /usr/src/app");
    //--no-browser --allow-root --port=8888
    contextObj.put("args", "--no-browser --allow-root --port=8888");
    //services port
    JSONArray services = contextObj.getJSONArray("services");
    if (services == null) {
        services = new JSONArray();
        contextObj.put("services", services);
    }
    services.add("8888");
    //jupyterWkdir
    JSONObject jupyterVolume = new JSONObject();
    jupyterVolume.put("path", jupyterWkdir);
    jupyterVolume.put("mountPath", " /usr/src/app");
    jupyterVolume.put("name", "volume-jupyter");
    //workingDir
    contextObj.put("workingDir", " /usr/src/app");
    //volumes.path
    JSONArray volumes = contextObj.getJSONArray("volumes");
    if (volumes == null) {
        volumes = new JSONArray();
        contextObj.put("volumes", volumes);
    }
    volumes.add(jupyterVolume);
    if (volumes != null && volumes.size() > 0) {
        for (int i = 0; i < volumes.size(); i++) {
            JSONObject volume = volumes.getJSONObject(i);
            if (volume != null && !volume.containsKey("path")) {
                File directory = DirectoryUtils.createDirectory(projectId.toString(), String.valueOf(creatorId), GdaiConstant.MODEL_DEV, String.valueOf(devId), volume.getString("name"));
                if (directory == null) {
                    throw new Exception("部署目录创建异常");
                }
                String path = directory.getAbsolutePath();
                volume.put("path", path);
            }
        }
    }
    //gpu
    JSONObject gpu = contextObj.getJSONObject("gpu");
    //envs
    JSONArray defaultEnvs = new JSONArray();
    if (gpu != null && gpu.size() > 0) {
        defaultEnvs.add(JSON.parseObject("{\"name\":\"NVIDIA_DRIVER_CAPABILITIES\",\"value\":\"compute,utility\"}"));
    } else {
        defaultEnvs.add(JSON.parseObject("{\"name\":\"NVIDIA_VISIBLE_DEVICES\",\"value\":\"void\"}"));
    }
    JSONArray envs = contextObj.getJSONArray("envs");
    if (envs != null && envs.size() > 0) {
        for (int i = 0; i < envs.size(); i++) {
            JSONObject env = envs.getJSONObject(i);
            if (env.containsKey("name") && ("NVIDIA_VISIBLE_DEVICES".equals(env.getString("name")) || "NVIDIA_DRIVER_CAPABILITIES".equals(env.getString("name")))) {
                continue;
            }
            defaultEnvs.add(env);
        }
    }
    contextObj.put("envs", defaultEnvs);
    context = JSON.toJSONString(contextObj);
    //TBD
    deploymentName = bizName;
    serviceName = bizName;
    podLabelSelector = "app=" + bizName;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
com.eshore.gdai.trainingcenter.util.DirectoryUtils
java.io.File
### 类级别的变量
@TableId(type = IdType.AUTO)
private Long /**
 * 开发ID
 */
devId;
/**
 * 项目ID
 */
private Long projectId;
/**
 * 用于查询pod的label,目前只存放一个
 */
private String podLabelSelector;
/**
 * k8s deployment的名字
 */
private String deploymentName;
/**
 * k8s service的名字
 */
private String serviceName;
/**
 * jupyter工作的物理目录
 */
private String jupyterWkdir;
/**
 * yaml模板配置参数
 */
private String context;
private Long creatorId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.entity下的类GdaiModelDeploy中有一个名为buildContext的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildContext() throws Exception {
    JSONObject contextObj = JSON.parseObject(context);
    String bizName = "deploy-model-" + servingId;
    //name
    contextObj.put("name", bizName);
    contextObj.put("bizType", "deploy_model");
    contextObj.put("bizEnv", LabelUtils.getBizEnvLabelStr());
    contextObj.put("bizId", String.valueOf(servingId));
    //volumes.path
    JSONArray volumes = contextObj.getJSONArray("volumes");
    if (volumes != null && volumes.size() > 0) {
        for (int i = 0; i < volumes.size(); i++) {
            JSONObject volume = volumes.getJSONObject(i);
            if (volume != null && !volume.containsKey("path")) {
                File directory = DirectoryUtils.createDirectory(projectId.toString(), String.valueOf(creatorId), GdaiConstant.MODEL_DEPLOY, String.valueOf(servingId), volume.getString("name"));
                if (directory == null) {
                    throw new Exception("部署目录创建异常");
                }
                String path = directory.getAbsolutePath();
                volume.put("path", path);
            }
        }
    }
    //gpu
    JSONObject gpu = contextObj.getJSONObject("gpu");
    //envs
    JSONArray defaultEnvs = new JSONArray();
    if (gpu != null && gpu.size() > 0) {
        defaultEnvs.add(JSON.parseObject("{\"name\":\"NVIDIA_DRIVER_CAPABILITIES\",\"value\":\"compute,utility\"}"));
    } else {
        defaultEnvs.add(JSON.parseObject("{\"name\":\"NVIDIA_VISIBLE_DEVICES\",\"value\":\"void\"}"));
    }
    JSONArray envs = contextObj.getJSONArray("envs");
    if (envs != null && envs.size() > 0) {
        for (int i = 0; i < envs.size(); i++) {
            JSONObject env = envs.getJSONObject(i);
            if (env.containsKey("name") && ("NVIDIA_VISIBLE_DEVICES".equals(env.getString("name")) || "NVIDIA_DRIVER_CAPABILITIES".equals(env.getString("name")))) {
                continue;
            }
            defaultEnvs.add(env);
        }
    }
    contextObj.put("envs", defaultEnvs);
    context = JSON.toJSONString(contextObj);
    //TBD
    pubDeploymentName = bizName;
    pubServiceName = bizName;
    pubPodLabelSelector = "app=" + bizName;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
com.eshore.gdai.trainingcenter.util.DirectoryUtils
java.io.File
### 类级别的变量
/**
 * 项目ID
 */
private Long projectId;
/**
 * 应用发布k8s deployment的名字
 */
private String pubDeploymentName;
/**
 * 应用发布k8s service的名字
 */
private String pubServiceName;
/**
 * 应用发布,用于查询pod的label,目前只存放一个
 */
private String pubPodLabelSelector;
/**
 * 服务ID
 */
private Long servingId;
/**
 * yaml模板配置参数
 */
private String context;
private Long creatorId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.entity下的类GdaiTrainingModel中有一个名为buildContext的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildContext() throws Exception {
    JSONObject contextObj = JSON.parseObject(context);
    String bizName = "train-model-" + trainId;
    //name
    contextObj.put("name", bizName);
    contextObj.put("bizType", "train_model");
    contextObj.put("bizEnv", LabelUtils.getBizEnvLabelStr());
    contextObj.put("bizId", String.valueOf(trainId));
    //volumes.path
    JSONArray volumes = contextObj.getJSONArray("volumes");
    if (volumes != null && volumes.size() > 0) {
        for (int i = 0; i < volumes.size(); i++) {
            JSONObject volume = volumes.getJSONObject(i);
            if (volume != null && !volume.containsKey("path")) {
                File directory = DirectoryUtils.createDirectory(projectId.toString(), String.valueOf(creatorId), GdaiConstant.MODEL_TRAIN, String.valueOf(trainId), volume.getString("name"));
                if (directory == null) {
                    throw new Exception("部署目录创建异常");
                }
                String path = directory.getAbsolutePath();
                volume.put("path", path);
            }
        }
    }
    //gpu
    JSONObject gpu = contextObj.getJSONObject("gpu");
    //envs
    JSONArray defaultEnvs = new JSONArray();
    if (gpu != null && gpu.size() > 0) {
        defaultEnvs.add(JSON.parseObject("{\"name\":\"NVIDIA_DRIVER_CAPABILITIES\",\"value\":\"compute,utility\"}"));
    } else {
        defaultEnvs.add(JSON.parseObject("{\"name\":\"NVIDIA_VISIBLE_DEVICES\",\"value\":\"void\"}"));
    }
    JSONArray envs = contextObj.getJSONArray("envs");
    if (envs != null && envs.size() > 0) {
        for (int i = 0; i < envs.size(); i++) {
            JSONObject env = envs.getJSONObject(i);
            if (env.containsKey("name") && ("NVIDIA_VISIBLE_DEVICES".equals(env.getString("name")) || "NVIDIA_DRIVER_CAPABILITIES".equals(env.getString("name")))) {
                continue;
            }
            defaultEnvs.add(env);
        }
    }
    contextObj.put("envs", defaultEnvs);
    context = JSON.toJSONString(contextObj);
    //TBD
    jobName = bizName;
    podLabelSelector = "app=" + bizName;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
com.eshore.gdai.trainingcenter.util.DirectoryUtils
java.io.File
### 类级别的变量
/**
 * 训练ID
 */
@TableId(type = IdType.AUTO)
private Long trainId;
/**
 * 项目ID
 */
private Long projectId;
/**
 * jodName
 */
private String jobName;
/**
 * 用于查询pod的label
 */
private String podLabelSelector;
/**
 * yaml模板配置参数
 */
private String context;
/**
 * creator_id
 */
private Long creatorId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.handler下的类MyWebSocketHandler中有一个名为handleTransportError的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 连接异常
     *
     * @param session
     * @param exception
     */
public void handleTransportError(WebSocketSession session, Throwable exception) {
    if (session.isOpen()) {
        log.info("session [" + session.getId() + "] is open, need close");
        try {
            session.close();
        } catch (IOException e) {
            log.error("session [" + session.getId() + "] close failed", e);
        }
    }
    sessionMap.remove(session.getId());
    log.error(String.format("websocket error, seesion[id:%s], \t %s", session.getId(), JSONObject.toJSONString(session.getAttributes())), exception);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
java.io.IOException
java.util.Map
### 类级别的变量
private Map<String, WebSocketSession> sessionMap = new ConcurrentHashMap<>();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.handler下的类ShellWebSocketHandler中有一个名为afterConnectionEstablished的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 建立连接
     *
     * @param session
     * @throws Exception
     */
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
    Map<String, String> requestParams = MapUrlParamsUtils.getUrlParams(session.getUri().getQuery());
    if (requestParams == null) {
        return;
    }
    //TBD 后续考虑通过Interceptor 在Handshake 的时候统一处理
    //        String submitedToken = requestParams.get("token");
    //        if (StringUtils.isEmpty(submitedToken)) {
    //            return;
    //        }
    //        String submitedToken=session.getHandshakeHeaders().get("sec-websocket-protocol").get(0);
    //        if(StringUtils.isEmpty(submitedToken)){
    //            submitedToken =requestParams.get("token");
    //        }
    //RedisHttpSession用的是JdkSerializationRedisSerializer，所以需要转换成JDK序列化方式
    //        byte[] bytes = (byte[]) redisUtils.hGet(("spring:session:sessions:" + submitedToken).getBytes(), "sessionAttr:user".getBytes());
    //        if (bytes == null) {
    //            log.info("获取用户信息失败：{}", requestParams.get("token")+"不存在");
    //            return;
    //        }
    //        try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
    //             ObjectInputStream ois = new ObjectInputStream(bais);) {
    //            // 读取对象
    //            User user = (User) ois.readObject();
    //            if (user == null) {
    //                return;
    //            }
    //            log.info(String.valueOf(user.getId()));
    //            //TBD 这里需要根据用户的权限来判断是否有权限进行操作
    //        } catch (Exception e) {
    //            log.info("获取用户信息失败：{}", e.getMessage());
    //            return;
    //        }
    if (TerminalWsConnections.size() < maximumPoolSize) {
        if (!TerminalWsConnections.containsKey(session.getId())) {
            Exec exec = new Exec();
            TerminalWsConnection terminalWsConnection = new TerminalWsConnection(requestParams, session, exec);
            TerminalWsConnections.putIfAbsent(session.getId(), terminalWsConnection);
            terminalThreadPoolExecutor.submit(terminalWsConnection);
            LOGGER.info("TerminalWsConnection connected, session id: {}, connecting count: {}", session.getId(), TerminalWsConnections.size());
        }
    } else {
        LOGGER.warn("terminal thread pool is full");
        TextMessage textMessage = new TextMessage("terminal thread pool is full".getBytes(StandardCharsets.UTF_8));
        session.sendMessage(textMessage);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.MapUrlParamsUtils
com.eshore.gdai.trainingcenter.vo.pod.TerminalWsConnection
io.kubernetes.client.Exec
org.springframework.web.socket.TextMessage
java.nio.charset.StandardCharsets
java.util.Map
### 类级别的变量
@Autowired
private RedisUtils redisUtils;
private static final Logger LOGGER = LoggerFactory.getLogger(ShellWebSocketHandler.class);
private static final int maximumPoolSize = 50;
private static final ConcurrentHashMap<String, TerminalWsConnection> TerminalWsConnections = new ConcurrentHashMap<>();
private static final ExecutorService terminalThreadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.handler下的类ShellWebSocketHandler中有一个名为afterConnectionClosed的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 关闭连接时触发
     *
     * @param session
     * @param closeStatus
     * @throws Exception
     */
public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
    if (TerminalWsConnections.containsKey(session.getId())) {
        TerminalWsConnections.get(session.getId()).exit();
        TerminalWsConnections.remove(session.getId());
        LOGGER.info("TerminalWsConnection disconnected, sessionId: {}, connecting count: {}", session.getId(), TerminalWsConnections.size());
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.TerminalWsConnection
### 类级别的变量
private static final Logger LOGGER = LoggerFactory.getLogger(ShellWebSocketHandler.class);
private static final ConcurrentHashMap<String, TerminalWsConnection> TerminalWsConnections = new ConcurrentHashMap<>();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.handler下的类ShellWebSocketHandler中有一个名为handleTextMessage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 处理消息
     *
     * @param session
     * @param message
     * @throws Exception
     */
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
    if (TerminalWsConnections.containsKey(session.getId())) {
        Process proc = TerminalWsConnections.get(session.getId()).getProc();
        if (proc != null) {
            if (session.isOpen()) {
                proc.getOutputStream().write(message.getPayload().getBytes(StandardCharsets.UTF_8));
            }
        }
        super.handleTextMessage(session, message);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.TerminalWsConnection
org.springframework.web.socket.TextMessage
java.nio.charset.StandardCharsets
### 类级别的变量
private static final ConcurrentHashMap<String, TerminalWsConnection> TerminalWsConnections = new ConcurrentHashMap<>();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.handler下的类ShellWebSocketHandler中有一个名为handleTransportError的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 处理传输错误
     *
     * @param session
     * @param exception
     * @throws Exception
     */
public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
    if (session.isOpen()) {
        session.close();
    }
    if (TerminalWsConnections.containsKey(session.getId())) {
        TerminalWsConnections.get(session.getId()).exit();
        TerminalWsConnections.remove(session.getId());
        LOGGER.info("TerminalWsConnection disconnected because of error: {}, connecting count: {}", exception.getMessage(), TerminalWsConnections.size());
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.TerminalWsConnection
### 类级别的变量
private static final Logger LOGGER = LoggerFactory.getLogger(ShellWebSocketHandler.class);
private static final ConcurrentHashMap<String, TerminalWsConnection> TerminalWsConnections = new ConcurrentHashMap<>();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.domain.bo下的类PodBo中有一个名为getPodFinalPhase的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据pod状态和容器状态结合判断最终状态
     * @return
     */
public String getPodFinalPhase() {
    if (("Running".equals(phase) || "Pending".equals(phase)) && !CollectionUtils.isEmpty(containerStatuses) && containerStatuses.get(0).getWaiting() != null) {
        //如果当前状态为running，但第一个容器处于等待状态，容器可能是处于启动中或者启动失败等待重试中
        String waitingReason = containerStatuses.get(0).getWaiting().getReason();
        //如果不是正在创建容器，则表示启动失败了，重试也不会成功，直接返回failed
        if (waitingReason != null && !"ContainerCreating".equals(waitingReason)) {
            return "Failed";
        }
        if (waitingReason != null) {
            return waitingReason;
        }
    }
    return phase;
}
### 类导入的包
org.springframework.util.CollectionUtils
### 类级别的变量
/**
 * Pod 的 phase 是对 Pod 在其生命周期中所处位置的简单、高级摘要。
 * phase 的取值有五种可能性：
 * Pending（悬决） Pod 已被 Kubernetes 系统接受，但尚未创建容器镜像。 这包括 Pod 被调度之前的时间以及通过网络下载镜像所花费的时间。
 * Running（运行中） Pod 已经被绑定到某个节点，并且所有的容器都已经创建完毕。至少有一个容器仍在运行，或者正在启动或重新启动过程中。
 * Succeeded（成功） Pod 中的所有容器都已成功终止，不会重新启动。
 * Failed（失败） Pod 中的所有容器都已终止，并且至少有一个容器因故障而终止。 容器要么以非零状态退出，要么被系统终止。
 * Unknown（未知）由于某种原因无法获取 Pod 的状态，通常是由于与 Pod 的主机通信时出错。
 * Terminating（终止）中间状态 (新版删除了)
 */
//status.phase
private String phase;
/**
 * 状态变化时间戳
 */
//status.conditions
//    private List<PodConditionBo> conditions;
/**
 * container 状态
 */
//status.containerStatuses
private List<ContainerStatusBo> containerStatuses;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.domain.bo下的类PodBo中有一个名为getPodFinalStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String getPodFinalStatus() {
    if (!CollectionUtils.isEmpty(containerStatuses) && containerStatuses.get(0).getWaiting() != null) {
        String waitingReason = containerStatuses.get(0).getWaiting().getReason();
        if (waitingReason != null) {
            return waitingReason;
        }
    }
    if (!CollectionUtils.isEmpty(containerStatuses) && containerStatuses.get(0).getTerminated() != null) {
        String terminatedReason = containerStatuses.get(0).getTerminated().getReason();
        if (terminatedReason != null) {
            return terminatedReason;
        }
    }
    return phase;
}
### 类导入的包
org.springframework.util.CollectionUtils
### 类级别的变量
/**
 * Pod 的 phase 是对 Pod 在其生命周期中所处位置的简单、高级摘要。
 * phase 的取值有五种可能性：
 * Pending（悬决） Pod 已被 Kubernetes 系统接受，但尚未创建容器镜像。 这包括 Pod 被调度之前的时间以及通过网络下载镜像所花费的时间。
 * Running（运行中） Pod 已经被绑定到某个节点，并且所有的容器都已经创建完毕。至少有一个容器仍在运行，或者正在启动或重新启动过程中。
 * Succeeded（成功） Pod 中的所有容器都已成功终止，不会重新启动。
 * Failed（失败） Pod 中的所有容器都已终止，并且至少有一个容器因故障而终止。 容器要么以非零状态退出，要么被系统终止。
 * Unknown（未知）由于某种原因无法获取 Pod 的状态，通常是由于与 Pod 的主机通信时出错。
 * Terminating（终止）中间状态 (新版删除了)
 */
//status.phase
private String phase;
/**
 * 状态变化时间戳
 */
//status.conditions
//    private List<PodConditionBo> conditions;
/**
 * container 状态
 */
//status.containerStatuses
private List<ContainerStatusBo> containerStatuses;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.domain.bo下的类PrometheusMetricBo中有一个名为getMetricsData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public MetricDataVo getMetricsData() {
    MetricDataVo metricDataVo = new MetricDataVo();
    if (this.data == null) {
        return metricDataVo;
    }
    if (this.data.getResult() == null || CollectionUtils.isEmpty(this.data.getResult())) {
        return metricDataVo;
    }
    List<MetricResultVo> metricResultVos = new ArrayList<MetricResultVo>();
    this.data.getResult().stream().forEach(metricResult -> {
        metricResultVos.add(new MetricResultVo(metricResult.getMetric(), metricResult.getValue(), metricResult.getValues()));
    });
    metricDataVo.setResultType(this.data.getResultType());
    metricDataVo.setResult(metricResultVos);
    return metricDataVo;
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.vo.MetricDataVo
com.eshore.gdai.trainingcenter.k8s.domain.vo.MetricResultVo
lombok.Data
org.springframework.util.CollectionUtils
java.util.ArrayList
java.util.List
### 类级别的变量
private MetricData data;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.domain.bo下的类QuantityBo中有一个名为reduce的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 不同单位相减
     *
     * @param quantityBo 减数
     * @param limitsKey   类型
     * @return QuantityBo
     */
public QuantityBo reduce(QuantityBo quantityBo, String limitsKey) {
    if (quantityBo == null || StringUtils.isAllEmpty(limitsKey)) {
        return this;
    }
    switch(limitsKey) {
        case K8sConstant.RESOURCE_QUOTA_CPU_LIMITS_KEY:
            Long cpuDiff = UnitConvertUtils.cpuFormatToCore(amount, format) - UnitConvertUtils.cpuFormatToCore(quantityBo.getAmount(), quantityBo.getFormat());
            return new QuantityBo(String.valueOf(cpuDiff), "");
        case K8sConstant.RESOURCE_QUOTA_MEMORY_LIMITS_KEY:
            Long memDiff = UnitConvertUtils.memFormatToGi(amount, format) - UnitConvertUtils.memFormatToGi(quantityBo.getAmount(), quantityBo.getFormat());
            return new QuantityBo(String.valueOf(memDiff), "Gi");
        case K8sConstant.RESOURCE_QUOTA_GPU_CORE_REQUESTS_KEY:
            Long gpuCoreDiff = Long.parseLong(amount) - Long.parseLong(quantityBo.getAmount());
            return new QuantityBo(String.valueOf(gpuCoreDiff), format);
        case K8sConstant.RESOURCE_QUOTA_GPU_MEMORY_REQUESTS_KEY:
            Long gpuMemoryDiff = UnitConvertUtils.gpuMemoryFormatToM(amount, format) - UnitConvertUtils.gpuMemoryFormatToM(quantityBo.getAmount(), quantityBo.getFormat());
            return new QuantityBo(String.valueOf(gpuMemoryDiff), "");
        case K8sConstant.RESOURCE_QUOTA_GPU_REQUESTS_KEY:
            Long gpuDiff = Long.parseLong(amount) - Long.parseLong(quantityBo.getAmount());
            return new QuantityBo(String.valueOf(gpuDiff), format);
        default:
            return null;
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.constant.K8sConstant
com.eshore.gdai.trainingcenter.util.UnitConvertUtils
org.apache.commons.lang3.StringUtils
### 类级别的变量
private String amount;
private String format;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.domain.bo下的类ResourceQuotaBo中有一个名为getFreeResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取余量
     * @return 余量列表
     */
public Map<String, QuantityBo> getFreeResource() {
    Map<String, QuantityBo> free = new HashMap<>();
    if (!CollectionUtils.isEmpty(hard)) {
        for (Map.Entry<String, QuantityBo> entry : hard.entrySet()) {
            if (used.get(entry.getKey()) != null) {
                QuantityBo freeQuantityBo = entry.getValue().reduce(used.get(entry.getKey()), entry.getKey());
                if (freeQuantityBo != null) {
                    free.put(entry.getKey(), freeQuantityBo);
                }
            }
        }
    }
    return free;
}
### 类导入的包
org.springframework.util.CollectionUtils
java.util.HashMap
java.util.Map
### 类级别的变量
//status.hard
private Map<String, QuantityBo> hard;
//status.used
private Map<String, QuantityBo> used;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.informer.callback下的类DeploymentCallback中有一个名为callback的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void callback(String type, DeploymentBo deploymentBo) {
    try {
        String bizId = deploymentBo.getLabels().get("bizId");
        if (StringUtils.isEmpty(bizId) || !StringUtils.isNumeric(bizId)) {
            return;
        }
        if ("dev_model".equalsIgnoreCase(deploymentBo.getLabels().get("biz"))) {
            GdaiDevModel gdaiDevModel = gdaiDevModelMapper.selectById(Long.valueOf(bizId));
            if (gdaiDevModel != null) {
                gdaiDevModel.setReplicas(deploymentBo.getReplicas());
                if (deploymentBo.getReadyReplicas() == null) {
                    gdaiDevModel.setReadyReplicas(0);
                } else {
                    gdaiDevModel.setReadyReplicas(deploymentBo.getReadyReplicas());
                }
                //                    gdaiDevModel.setModifyTime(new Date());
                gdaiDevModelService.updateCurrentStatus(gdaiDevModel);
                gdaiDevModelMapper.updateForCallback(gdaiDevModel);
                //处理长时间异常的资源。
                gdaiDevModelService.handleResource(deploymentBo, gdaiDevModel);
            }
        } else if ("deploy_model".equalsIgnoreCase(deploymentBo.getLabels().get("biz"))) {
            GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(Long.valueOf(bizId));
            if (gdaiModelDeploy != null) {
                gdaiModelDeploy.setReplicas(deploymentBo.getReplicas());
                if (deploymentBo.getReadyReplicas() == null) {
                    gdaiModelDeploy.setReadyReplicas(0);
                } else {
                    gdaiModelDeploy.setReadyReplicas(deploymentBo.getReadyReplicas());
                }
                //                    gdaiModelDeploy.setModifyTime(new Date());
                gdaiModelDeployService.updateCurrentStatus(gdaiModelDeploy);
                gdaiModelDeployMapper.updateForCallback(gdaiModelDeploy);
                //处理长时间异常的资源。
                gdaiModelDeployService.handleResource(deploymentBo, gdaiModelDeploy);
                //处理服务激活
                gdaiModelDeployService.activeHandle(gdaiModelDeploy);
                //主动通知服务状态给杨璐更新
                RestResult restResult = FeignServiceHelper.reflowOrderResult(userClient, (JSONObject) JSON.toJSON(gdaiModelDeploy));
                if (restResult == null) {
                    log.info("回流接口返回为空");
                } else {
                    //回流接口调用成功
                    String code = restResult.getCode();
                    String message = restResult.getMessage();
                    if (code.equals("200")) {
                        log.info("调用回流接口成功", message);
                    } else {
                        log.info("调用回流接口失败", message);
                    }
                }
            }
        } else if ("train_model".equalsIgnoreCase(deploymentBo.getLabels().get("biz"))) {
        } else {
        }
        //dev_model
        //            if ("dev_model".equalsIgnoreCase(podBo.getLabels().get("biz"))) {
        //                if (StringUtils.isNotEmpty(podBo.getLabels().get("bizId"))) {
        //                    gdaiDevModelService.handleCallback(type, podBo);
        //
        ////                if ("MODIFIED".equalsIgnoreCase(type)) {
        ////                    GdaiDevModel gdaiDevModel = gdaiDevModelMapper.selectById(devId);
        ////                    if (("S0C".equals(gdaiDevModel.getStatus()) || "S0T".equals(gdaiDevModel.getStatus()))
        ////                            && "Running".equals(podBo.getPodFinalPhase())) {
        ////                        gdaiDevModel.setPodName(podBo.getName());
        ////                        gdaiDevModel.setStatus("S0R");
        ////                        gdaiDevModel.setModifyTime(new Date());
        ////                        gdaiDevModelMapper.updateById(gdaiDevModel);
        ////                        log.info("dev_model podCallback:" + gdaiDevModel.getStatus());
        ////                    } else if (("S0C".equals(gdaiDevModel.getStatus()) || "S0T".equals(gdaiDevModel.getStatus()))
        ////                            && "Failed".equals(podBo.getPodFinalPhase())) {
        ////                        gdaiDevModel.setStatus("S0C");
        ////                        gdaiDevModel.setModifyTime(new Date());
        ////                        gdaiDevModelMapper.updateById(gdaiDevModel);
        ////                        log.info("dev_model podCallback:" + gdaiDevModel.getStatus());
        ////                    }
        ////                } else if ("DELETED".equalsIgnoreCase(type)) {
        ////                    GdaiDevModel gdaiDevModel = gdaiDevModelMapper.selectById(devId);
        ////                    if ("S0TC".equals(gdaiDevModel.getStatus())) {
        ////                        gdaiDevModel.setStatus("S0T");
        ////                        gdaiDevModel.setModifyTime(new Date());
        ////                        gdaiDevModelMapper.updateById(gdaiDevModel);
        ////                        log.info("dev_model podCallback:" + gdaiDevModel.getStatus());
        ////                    } else if ("S0D".equals(gdaiDevModel.getStatus())) {
        //////                    gdaiDevModelMapper.deleteById(devId);
        ////                        log.info("dev_model podCallback:deleted");
        ////                    }
        ////                }
        //                }
        //            }
        //
        //
        //            //train_model
        //
        //            //deploy_model
        //            if ("deploy_model".equalsIgnoreCase(podBo.getLabels().get("biz"))) {
        //                if (StringUtils.isNotEmpty(podBo.getLabels().get("bizId"))) {
        //                    Long devId = Long.valueOf(podBo.getLabels().get("bizId"));
        //                    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectById(devId);
        //                    if (gdaiModelDeploy != null) {
        //                        gdaiModelDeploy.setPubPodName(podBo.getName());
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        //状态不一致的，需要更新状态。
        //                        if (("MODIFIED".equalsIgnoreCase(type) && "Running".equals(podBo.getPodFinalPhase()))
        //                                && !"S0R".equals(gdaiModelDeploy.getStatus())) {
        //                            gdaiModelDeploy.setStatus("S0R");
        //                            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                            log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                        } else if (("MODIFIED".equalsIgnoreCase(type) && "Failed".equals(podBo.getPodFinalPhase()))
        //                                && !"S0E".equals(gdaiModelDeploy.getStatus())) {
        //                            gdaiModelDeploy.setStatus("S0E");
        //                            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                            log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                        } else if ("DELETED".equalsIgnoreCase(type)) {
        //                            gdaiModelDeploy.setStatus("S0T");
        //                            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                            log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                        }
        //                    }
        //                }
        //            }
        //            if (StringUtils.isNotEmpty(podBo.getLabels().get("bizId"))) {
        //                Long servingId = Long.valueOf(podBo.getLabels().get("bizId"));
        //                if ("MODIFIED".equalsIgnoreCase(type)) {
        //                    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        //                    if (("S0C".equals(gdaiModelDeploy.getStatus()) || "S0T".equals(gdaiModelDeploy.getStatus()))
        //                            && "Running".equals(podBo.getPodFinalPhase())) {
        //                        gdaiModelDeploy.setPubPodName(podBo.getName());
        //                        gdaiModelDeploy.setStatus("S0R");
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //
        //                        log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                    } else if (("S0C".equals(gdaiModelDeploy.getStatus()) || "S0T".equals(gdaiModelDeploy.getStatus()))
        //                            && "Failed".equals(podBo.getPodFinalPhase())) {
        //                        gdaiModelDeploy.setStatus("S0C");
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //
        //                        log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                    }
        //                } else if ("DELETED".equalsIgnoreCase(type)) {
        //                    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        //                    if ("S0TC".equals(gdaiModelDeploy.getStatus())) {
        //                        gdaiModelDeploy.setStatus("S0T");
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //
        //                        log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                    } else if ("S0D".equals(gdaiModelDeploy.getStatus())) {
        ////                        gdaiModelDeployMapper.deleteById(servingId);
        //
        //                        log.info("deploy_model podCallback:deleted");
        //                    }
        //                }
        //            }
    } catch (Exception e) {
        log.error("podCallback {} {}", e.getMessage(), deploymentBo.getName());
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
org.apache.commons.lang3.StringUtils
javax.annotation.Resource
### 类级别的变量
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiDevModelService gdaiDevModelService;
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.informer.callback下的类JobCallback中有一个名为callback的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void callback(String type, JobBo jobBo) {
    try {
        String bizId = jobBo.getLabels().get("bizId");
        if (StringUtils.isEmpty(bizId) || !StringUtils.isNumeric(bizId)) {
            return;
        }
        GdaiTrainingModel trainingModel = gdaiTrainingModelMapper.selectById(Long.valueOf(bizId));
        if (trainingModel != null) {
            String status = "";
            if (jobBo.getStatus().getActive() != null) {
                status = "Running";
            } else if (jobBo.getStatus().getFailed() != null) {
                status = "Failed";
            } else if (jobBo.getStatus().getSucceeded() != null) {
                status = "Succeeded";
            }
            if (StringUtils.isNotEmpty(status) && !status.equalsIgnoreCase(trainingModel.getStatus())) {
                trainingModel.setStatus(status);
                if (status.equalsIgnoreCase("Succeeded")) {
                    trainingModel.setModifyTime(DateUtil.strToDate(jobBo.getStatus().getCompletionTime()));
                } else {
                    trainingModel.setModifyTime(new Date());
                }
                gdaiTrainingModelMapper.updateForCallback(trainingModel);
                if ("intelligent_annotation_model".equalsIgnoreCase(jobBo.getLabels().get("biz"))) {
                    gdaiIntelligentAnnotationService.handleIntelligentAnnotationBiz(trainingModel);
                }
            }
        }
    } catch (Exception e) {
        log.error("job callback {} {}", e.getMessage(), jobBo.getName());
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.util.DateUtil
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationService gdaiIntelligentAnnotationService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.informer.callback下的类PodCallback中有一个名为callback的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void callback(String type, PodBo podBo) {
    try {
        //podBo.getLabels().get("bizId") 是空的或不是数值类型，直接返回
        String bizId = podBo.getLabels().get("bizId");
        if (StringUtils.isEmpty(bizId) || !StringUtils.isNumeric(bizId)) {
            return;
        }
        GdaiPod gdaiPod = gdaiPodService.selectGdaiPod(Long.valueOf(bizId), podBo.getName());
        //有记录，做更改和删除操作；
        if (gdaiPod != null) {
            if ("delete".equalsIgnoreCase(type)) {
                gdaiPodService.deleteById(gdaiPod.getId());
            } else if ("update".equalsIgnoreCase(type)) {
                //if(!Objects.equals(gdaiPod.getPhase(),podBo.getPodFinalPhase())){
                gdaiPod.setPhase(podBo.getPodFinalPhase());
                gdaiPod.setModifyTime(new Date());
                gdaiPod.setMessage(gdaiPodService.buildMessage(gdaiPod.getMessage(), podBo));
                gdaiPod.setContent(JSONObject.toJSONString(podBo));
                gdaiPodService.updateById(gdaiPod);
                //}
            }
        } else {
            //无记录，新增与更新pod直接添加。
            if ("add".equalsIgnoreCase(type) || "update".equalsIgnoreCase(type)) {
                gdaiPod = GdaiPod.builder().name(podBo.getName()).namespace(podBo.getNamespace()).bizId(Long.valueOf(podBo.getLabels().get("bizId"))).bizName(podBo.getLabels().get("app")).bizType(podBo.getLabels().get("biz")).projectId(Long.valueOf(podBo.getNamespace().replace("gdai-", ""))).phase(podBo.getPodFinalPhase()).message(gdaiPodService.buildMessage("{}", podBo)).content(JSONObject.toJSONString(podBo)).createTime(new Date()).build();
                gdaiPodService.add(gdaiPod);
            }
        }
        //dev_model
        //            if ("dev_model".equalsIgnoreCase(podBo.getLabels().get("biz"))) {
        //                if (StringUtils.isNotEmpty(podBo.getLabels().get("bizId"))) {
        //                    gdaiDevModelService.handleCallback(type, podBo);
        //
        ////                if ("MODIFIED".equalsIgnoreCase(type)) {
        ////                    GdaiDevModel gdaiDevModel = gdaiDevModelMapper.selectById(devId);
        ////                    if (("S0C".equals(gdaiDevModel.getStatus()) || "S0T".equals(gdaiDevModel.getStatus()))
        ////                            && "Running".equals(podBo.getPodFinalPhase())) {
        ////                        gdaiDevModel.setPodName(podBo.getName());
        ////                        gdaiDevModel.setStatus("S0R");
        ////                        gdaiDevModel.setModifyTime(new Date());
        ////                        gdaiDevModelMapper.updateById(gdaiDevModel);
        ////                        log.info("dev_model podCallback:" + gdaiDevModel.getStatus());
        ////                    } else if (("S0C".equals(gdaiDevModel.getStatus()) || "S0T".equals(gdaiDevModel.getStatus()))
        ////                            && "Failed".equals(podBo.getPodFinalPhase())) {
        ////                        gdaiDevModel.setStatus("S0C");
        ////                        gdaiDevModel.setModifyTime(new Date());
        ////                        gdaiDevModelMapper.updateById(gdaiDevModel);
        ////                        log.info("dev_model podCallback:" + gdaiDevModel.getStatus());
        ////                    }
        ////                } else if ("DELETED".equalsIgnoreCase(type)) {
        ////                    GdaiDevModel gdaiDevModel = gdaiDevModelMapper.selectById(devId);
        ////                    if ("S0TC".equals(gdaiDevModel.getStatus())) {
        ////                        gdaiDevModel.setStatus("S0T");
        ////                        gdaiDevModel.setModifyTime(new Date());
        ////                        gdaiDevModelMapper.updateById(gdaiDevModel);
        ////                        log.info("dev_model podCallback:" + gdaiDevModel.getStatus());
        ////                    } else if ("S0D".equals(gdaiDevModel.getStatus())) {
        //////                    gdaiDevModelMapper.deleteById(devId);
        ////                        log.info("dev_model podCallback:deleted");
        ////                    }
        ////                }
        //                }
        //            }
        //
        //
        //            //train_model
        //
        //            //deploy_model
        //            if ("deploy_model".equalsIgnoreCase(podBo.getLabels().get("biz"))) {
        //                if (StringUtils.isNotEmpty(podBo.getLabels().get("bizId"))) {
        //                    Long devId = Long.valueOf(podBo.getLabels().get("bizId"));
        //                    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectById(devId);
        //                    if (gdaiModelDeploy != null) {
        //                        gdaiModelDeploy.setPubPodName(podBo.getName());
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        //状态不一致的，需要更新状态。
        //                        if (("MODIFIED".equalsIgnoreCase(type) && "Running".equals(podBo.getPodFinalPhase()))
        //                                && !"S0R".equals(gdaiModelDeploy.getStatus())) {
        //                            gdaiModelDeploy.setStatus("S0R");
        //                            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                            log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                        } else if (("MODIFIED".equalsIgnoreCase(type) && "Failed".equals(podBo.getPodFinalPhase()))
        //                                && !"S0E".equals(gdaiModelDeploy.getStatus())) {
        //                            gdaiModelDeploy.setStatus("S0E");
        //                            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                            log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                        } else if ("DELETED".equalsIgnoreCase(type)) {
        //                            gdaiModelDeploy.setStatus("S0T");
        //                            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                            log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                        }
        //                    }
        //                }
        //            }
        //            if (StringUtils.isNotEmpty(podBo.getLabels().get("bizId"))) {
        //                Long servingId = Long.valueOf(podBo.getLabels().get("bizId"));
        //                if ("MODIFIED".equalsIgnoreCase(type)) {
        //                    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        //                    if (("S0C".equals(gdaiModelDeploy.getStatus()) || "S0T".equals(gdaiModelDeploy.getStatus()))
        //                            && "Running".equals(podBo.getPodFinalPhase())) {
        //                        gdaiModelDeploy.setPubPodName(podBo.getName());
        //                        gdaiModelDeploy.setStatus("S0R");
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //
        //                        log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                    } else if (("S0C".equals(gdaiModelDeploy.getStatus()) || "S0T".equals(gdaiModelDeploy.getStatus()))
        //                            && "Failed".equals(podBo.getPodFinalPhase())) {
        //                        gdaiModelDeploy.setStatus("S0C");
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //
        //                        log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                    }
        //                } else if ("DELETED".equalsIgnoreCase(type)) {
        //                    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        //                    if ("S0TC".equals(gdaiModelDeploy.getStatus())) {
        //                        gdaiModelDeploy.setStatus("S0T");
        //                        gdaiModelDeploy.setModifyTime(new Date());
        //                        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //
        //                        log.info("deploy_model podCallback:" + gdaiModelDeploy.getStatus());
        //                    } else if ("S0D".equals(gdaiModelDeploy.getStatus())) {
        ////                        gdaiModelDeployMapper.deleteById(servingId);
        //
        //                        log.info("deploy_model podCallback:deleted");
        //                    }
        //                }
        //            }
    } catch (Exception e) {
        log.error("podCallback {} {}", e.getMessage(), podBo.getName());
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiPod
org.apache.commons.lang3.StringUtils
java.util.Date
java.util.Objects
### 类级别的变量
@Resource
private GdaiPodService gdaiPodService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.informer.watcher下的类DeploymentWatcher中有一个名为watch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    @SneakyThrows
public void watch(ApiClient client) {
    String labelSelector = LabelUtils.getLabelsStr(LabelUtils.getBizEnvLabel());
    AppsV1Api appsV1Api = new AppsV1Api(client);
    factory.sharedIndexInformerFor((CallGeneratorParams callGeneratorParams) -> {
        try {
            return appsV1Api.listDeploymentForAllNamespacesCall(null, null, null, labelSelector, null, null, callGeneratorParams.resourceVersion, null, callGeneratorParams.timeoutSeconds, callGeneratorParams.watch, null);
        } catch (ApiException e) {
            log.error("Unknown exception occurred", e);
            throw e;
        }
    }, V1Deployment.class, V1DeploymentList.class).addEventHandler(this);
    factory.startAllRegisteredInformers();
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1DeploymentList
io.kubernetes.client.util.CallGeneratorParams
### 类级别的变量
@Resource
private SharedInformerFactory factory;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.informer.watcher下的类JobWatcher中有一个名为watch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    @SneakyThrows
public void watch(ApiClient client) {
    String labelSelector = LabelUtils.getLabelsStr(LabelUtils.getBizEnvLabel());
    BatchV1Api appsV1Api = new BatchV1Api(client);
    factory.sharedIndexInformerFor((CallGeneratorParams callGeneratorParams) -> {
        try {
            return appsV1Api.listJobForAllNamespacesCall(null, null, null, labelSelector, null, null, callGeneratorParams.resourceVersion, null, callGeneratorParams.timeoutSeconds, callGeneratorParams.watch, null);
        } catch (ApiException e) {
            log.error("Unknown exception occurred", e);
            throw e;
        }
    }, V1Job.class, V1JobList.class).addEventHandler(this);
    factory.startAllRegisteredInformers();
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
io.kubernetes.client.util.CallGeneratorParams
### 类级别的变量
@Resource
private SharedInformerFactory factory;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.informer.watcher下的类PodWatcher中有一个名为watch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    @SneakyThrows
public void watch(ApiClient client) {
    String labelSelector = LabelUtils.getLabelsStr(LabelUtils.getBizEnvLabel());
    CoreV1Api coreV1Api = new CoreV1Api(client);
    factory.sharedIndexInformerFor((CallGeneratorParams callGeneratorParams) -> {
        try {
            return coreV1Api.listPodForAllNamespacesCall(null, null, null, labelSelector, null, null, callGeneratorParams.resourceVersion, null, callGeneratorParams.timeoutSeconds, callGeneratorParams.watch, null);
        } catch (ApiException e) {
            log.error("Unknown exception occurred", e);
            throw e;
        }
    }, V1Pod.class, V1PodList.class).addEventHandler(this);
    factory.startAllRegisteredInformers();
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
io.kubernetes.client.util.CallGeneratorParams
### 类级别的变量
@Resource
private SharedInformerFactory factory;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类DeploymentServiceImpl中有一个名为listAll的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<DeploymentBo> listAll(String clusterName, String labelSelector) throws Exception {
    log.info("DeploymentServiceImpl.listAll params: [{},{}]", clusterName, labelSelector);
    try {
        AppsV1Api apps = k8sClientOperator.getAppsV1Api(clusterName);
        V1DeploymentList deploymentList = apps.listDeploymentForAllNamespaces(null, null, null, labelSelector, null, null, null, null, null, null);
        return convert(deploymentList);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.DeploymentService
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1DeploymentList
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类DeploymentServiceImpl中有一个名为createDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public DeploymentBo createDeployment(String clusterName, String namespace, V1Deployment body) throws Exception {
    log.info("DeploymentServiceImpl.createDeployment params: [clusterName={},namespace={}]", clusterName, namespace);
    try {
        AppsV1Api apps = k8sClientOperator.getAppsV1Api(clusterName);
        V1Deployment v1Deployment = apps.createNamespacedDeployment(namespace, body, null, null, null);
        return deploymentConvert.mappingTo(v1Deployment);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.DeploymentService
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.models.V1Deployment
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private DeploymentConvert deploymentConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类DeploymentServiceImpl中有一个名为createDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public DeploymentBo createDeployment(String clusterName, String namespace, String yamlContent) throws Exception {
    log.info("DeploymentServiceImpl.createDeployment params: [clusterName={},namespace={},yamlContent={}]", clusterName, namespace, yamlContent);
    try {
        V1Deployment deployment = YamlUtil.loadK8sObject(yamlContent, "Deployment", V1Deployment.class);
        return createDeployment(clusterName, namespace, deployment);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.DeploymentService
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.models.V1Deployment
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类DeploymentServiceImpl中有一个名为scaleDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void scaleDeployment(String clusterName, String nameSpace, String deploymentName, Integer instances) throws Exception {
    AppsV1Api apps = k8sClientOperator.getAppsV1Api(clusterName);
    String jsonPatchStr = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\", \"value\": " + instances + " }]";
    V1Patch body = new V1Patch(jsonPatchStr);
    apps.patchNamespacedDeployment(deploymentName, nameSpace, body, null, null, null, null);
}
### 类导入的包
io.kubernetes.client.custom.V1Patch
io.kubernetes.client.openapi.apis.AppsV1Api
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类JobServiceImpl中有一个名为listAll的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<JobBo> listAll(String clusterName, String labelSelector) throws Exception {
    log.info("JobServiceImpl.listAll params: [{},{}]", clusterName, labelSelector);
    try {
        BatchV1Api api = k8sClientOperator.getBatchV1Api(clusterName);
        V1JobList jobList = api.listJobForAllNamespaces(null, null, null, labelSelector, null, null, null, null, null, null);
        return convert(jobList);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.JobService
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类JobServiceImpl中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JobBo get(String clusterName, String namespace, String jobName) throws Exception {
    log.info("JobServiceImpl.get params: [{},{}]", clusterName, jobName);
    try {
        BatchV1Api api = k8sClientOperator.getBatchV1Api(clusterName);
        V1Job job = api.readNamespacedJob(jobName, namespace, null);
        return jobConvert.mappingTo(job);
    } catch (Exception e) {
        throw new TrainginCenterException("获取服务信息失败！" + e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.JobService
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.models.V1Job
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private JobConvert jobConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类JobServiceImpl中有一个名为createJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JobBo createJob(String clusterName, String namespace, V1Job body) throws Exception {
    log.info("JobServiceImpl.createJob params: [clusterName={},namespace={}]", clusterName, namespace);
    try {
        BatchV1Api api = k8sClientOperator.getBatchV1Api(clusterName);
        V1Job job = api.createNamespacedJob(namespace, body, null, null, null);
        return jobConvert.mappingTo(job);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.JobService
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.models.V1Job
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private JobConvert jobConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类JobServiceImpl中有一个名为createJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JobBo createJob(String clusterName, String namespace, String yamlContent) throws Exception {
    log.info("JobServiceImpl.createJob params: [clusterName={},namespace={},yamlContent={}]", clusterName, namespace, yamlContent);
    try {
        V1Job job = YamlUtil.loadK8sObject(yamlContent, "Job", V1Job.class);
        return createJob(clusterName, namespace, job);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.JobService
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.models.V1Job
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类MetricsServiceImpl中有一个名为getMetrics的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<MetricsResultsVo> getMetrics(String queryParams, Long startTime, Long endTime, Integer step, String nodeName, String gpuName, String dockerDataPath, String podName) throws TrainginCenterException {
    List<MetricsResultsVo> metricsResultsVoList = new ArrayList<>();
    // 校验输入参数
    if (queryParams == null || startTime == null || endTime == null || step == null) {
        throw new TrainginCenterException("Invalid input parameters");
    }
    // 使用Stream处理queryParams的分割和查询
    Stream.of(queryParams.split("\\|")).map(queryParam -> {
        Map<String, Object> param = getQueryRangeParamMap(queryParam, startTime, endTime, step, nodeName, dockerDataPath, gpuName, podName);
        return queryPrometheus(queryParam, param);
    }).forEach(metricsResultsVoList::add);
    return metricsResultsVoList;
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.domain.vo.MetricsResultsVo
java.util.stream.Stream
### 类级别的变量
private String query = "api/v1/query";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类MetricsServiceImpl中有一个名为queryPrometheus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private MetricsResultsVo queryPrometheus(String queryParam, Map<String, Object> param) {
    try {
        PrometheusMetricBo metricBo = PrometheusUtil.getQuery(url + queryRange, param);
        return new MetricsResultsVo(queryParam, metricBo.getMetricsData());
    } catch (Exception e) {
        log.info("Failed to query Prometheus: %s", e.getMessage());
    }
    return null;
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.PrometheusMetricBo
com.eshore.gdai.trainingcenter.k8s.domain.vo.MetricsResultsVo
com.eshore.gdai.trainingcenter.k8s.util.PrometheusUtil
### 类级别的变量
/**
 * cephfs挂载根目录
 */
@Value("${prometheus.url}")
private String url;
private String query = "api/v1/query";
private String queryRange = "api/v1/query_range";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类MetricsServiceImpl中有一个名为getNodeGpuInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<JSONObject> getNodeGpuInfo(String nodeName, Long time) {
    Map<String, JSONObject> resultMap = new HashMap<>();
    PrometheusMetricBo nodeVgpuTotal = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeParamMap(nodeVgpuTotalQueryParam, time, nodeName));
    if (nodeVgpuTotal != null && nodeVgpuTotal.getMetricsData() != null && nodeVgpuTotal.getMetricsData().getResult() != null) {
        nodeVgpuTotal.getMetricsData().getResult().forEach(result -> {
            JSONObject resultObject = new JSONObject();
            String key;
            JSONObject metric = JSON.parseObject(JSON.toJSONString(result.getMetric()));
            key = metric.getString("gpu");
            resultObject.put("gpu", metric.getString("gpu"));
            resultObject.put("model_name", metric.getString("model_name"));
            String value = String.valueOf(result.getValue().get(1));
            resultObject.put("vgpu_total", value);
            resultMap.put(key, resultObject);
        });
    }
    PrometheusMetricBo nodeVgpuUsed = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeParamMap(nodeVgpuUsedQueryParam, time, nodeName));
    if (nodeVgpuUsed != null && nodeVgpuUsed.getMetricsData() != null && nodeVgpuUsed.getMetricsData().getResult() != null) {
        nodeVgpuUsed.getMetricsData().getResult().forEach(result -> {
            String key;
            JSONObject metric = JSON.parseObject(JSON.toJSONString(result.getMetric()));
            key = metric.getString("gpu");
            JSONObject resultObject = resultMap.get(key);
            String value = String.valueOf(result.getValue().get(1));
            resultObject.put("vgpu_used", value);
            //resultMap.put(key, resultObject);
        });
    }
    PrometheusMetricBo nodeGpuCoreUsed = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeParamMap(nodeGpuCoreUsedQueryParam, time, nodeName));
    if (nodeGpuCoreUsed != null && nodeGpuCoreUsed.getMetricsData() != null && nodeGpuCoreUsed.getMetricsData().getResult() != null) {
        nodeGpuCoreUsed.getMetricsData().getResult().forEach(result -> {
            String key;
            JSONObject metric = JSON.parseObject(JSON.toJSONString(result.getMetric()));
            key = metric.getString("gpu");
            JSONObject resultObject = resultMap.get(key);
            String value = String.valueOf(result.getValue().get(1));
            resultObject.put("gpu_core_used", value);
            //resultMap.put(key, resultObject);
        });
    }
    PrometheusMetricBo nodeGpuMemoryTotal = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeParamMap(nodeGpuMemoryTotalQueryParam, time, nodeName));
    if (nodeGpuMemoryTotal != null && nodeGpuMemoryTotal.getMetricsData() != null && nodeGpuMemoryTotal.getMetricsData().getResult() != null) {
        nodeGpuMemoryTotal.getMetricsData().getResult().forEach(result -> {
            String key;
            JSONObject metric = JSON.parseObject(JSON.toJSONString(result.getMetric()));
            key = metric.getString("gpu");
            JSONObject resultObject = resultMap.get(key);
            String value = String.valueOf(result.getValue().get(1));
            resultObject.put("gpu_memory_total", value);
            //resultMap.put(key, resultObject);
        });
    }
    PrometheusMetricBo nodeGpuMemoryUsed = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeParamMap(nodeGpuMemoryUsedQueryParam, time, nodeName));
    if (nodeGpuMemoryUsed != null && nodeGpuMemoryUsed.getMetricsData() != null && nodeGpuMemoryUsed.getMetricsData().getResult() != null) {
        nodeGpuMemoryUsed.getMetricsData().getResult().forEach(result -> {
            String key;
            JSONObject metric = JSON.parseObject(JSON.toJSONString(result.getMetric()));
            key = metric.getString("gpu");
            JSONObject resultObject = resultMap.get(key);
            String value = String.valueOf(result.getValue().get(1));
            resultObject.put("gpu_memory_used", value);
            //resultMap.put(key, resultObject);
        });
    }
    return new ArrayList<>(resultMap.values());
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.k8s.domain.bo.PrometheusMetricBo
com.eshore.gdai.trainingcenter.k8s.util.PrometheusUtil
org.springframework.beans.factory.annotation.Value
### 类级别的变量
/**
 * cephfs挂载根目录
 */
@Value("${prometheus.url}")
private String url;
private String query = "api/v1/query";
//GPU设备 信息
private String nodeVgpuTotalQueryParam = "node_vgpu_total{node='node-name'}";
private String nodeVgpuUsedQueryParam = "node_vgpu_used{node='node-name'}";
private String nodeGpuCoreUsedQueryParam = "node_gpu_core_used{node='node-name'}";
private String nodeGpuMemoryTotalQueryParam = "node_gpu_memory_total{node='node-name'}";
private String nodeGpuMemoryUsedQueryParam = "node_gpu_memory_used{node='node-name'}";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类MetricsServiceImpl中有一个名为getNodeGpuContainerInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<JSONObject> getNodeGpuContainerInfo(String nodeName, String gpuName, Long time) {
    Map<String, JSONObject> resultMap = new LinkedHashMap<>();
    PrometheusMetricBo containerRequestGpuUtilization = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeGpuParamMap(containerRequestGpuUtilizationQueryParam, time, nodeName, gpuName));
    if (containerRequestGpuUtilization != null && containerRequestGpuUtilization.getMetricsData() != null && containerRequestGpuUtilization.getMetricsData().getResult() != null) {
        containerRequestGpuUtilization.getMetricsData().getResult().forEach(result -> {
            JSONObject resultObject = new JSONObject();
            String key;
            JSONObject metric = JSON.parseObject(JSON.toJSONString(result.getMetric()));
            key = metric.getString("pod_name");
            resultObject.put("pod_name", metric.getString("pod_name"));
            resultObject.put("namespace", metric.getString("namespace"));
            String value = String.valueOf(result.getValue().get(1));
            resultObject.put("container_request_gpu_utilization", (int) (Double.parseDouble(value) * 100));
            resultMap.put(key, resultObject);
        });
    }
    PrometheusMetricBo containerRequestGpuMemory = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeGpuParamMap(containerRequestGpuMemoryQueryParam, time, nodeName, gpuName));
    if (containerRequestGpuMemory != null && containerRequestGpuMemory.getMetricsData() != null && containerRequestGpuMemory.getMetricsData().getResult() != null) {
        containerRequestGpuMemory.getMetricsData().getResult().forEach(result -> {
            String key;
            JSONObject metric = JSON.parseObject(JSON.toJSONString(result.getMetric()));
            key = metric.getString("pod_name");
            JSONObject resultObject = resultMap.get(key);
            String value = String.valueOf(result.getValue().get(1));
            resultObject.put("container_request_gpu_memory", value);
            //resultMap.put(key, resultObject);
        });
    }
    Integer gpuMemoryTotal = 0;
    PrometheusMetricBo nodeGpuMemoryTotalByGpu = PrometheusUtil.getQuery(url + query, PrometheusUtil.getQueryNodeGpuParamMap(nodeGpuMemoryTotalByGpuQueryParam, time, nodeName, gpuName));
    if (nodeGpuMemoryTotalByGpu != null && nodeGpuMemoryTotalByGpu.getMetricsData() != null && nodeGpuMemoryTotalByGpu.getMetricsData().getResult() != null) {
        gpuMemoryTotal = Integer.parseInt(String.valueOf(nodeGpuMemoryTotalByGpu.getMetricsData().getResult().get(0).getValue().get(1)));
    }
    Integer gpuMemory = resultMap.values().stream().mapToInt((JSONObject v) -> Integer.parseInt(v.getString("container_request_gpu_memory"))).sum();
    Integer gpuutilization = resultMap.values().stream().mapToInt((JSONObject v) -> Integer.parseInt(v.getString("container_request_gpu_utilization"))).sum();
    JSONObject remain = new JSONObject();
    remain.put("container_request_gpu_memory", gpuMemoryTotal - gpuMemory);
    remain.put("container_request_gpu_utilization", 100 - gpuutilization);
    remain.put("pod_name", "未分配");
    remain.put("namespace", "未分配");
    resultMap.put("remain", remain);
    return new ArrayList<>(resultMap.values());
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.k8s.domain.bo.PrometheusMetricBo
com.eshore.gdai.trainingcenter.k8s.util.PrometheusUtil
org.springframework.beans.factory.annotation.Value
java.util
### 类级别的变量
/**
 * cephfs挂载根目录
 */
@Value("${prometheus.url}")
private String url;
private String query = "api/v1/query";
private String nodeGpuMemoryTotalByGpuQueryParam = "node_gpu_memory_total{node='node-name',gpu='gpu-name'}";
private String containerRequestGpuUtilizationQueryParam = "container_request_gpu_utilization{node='node-name',req_of_gpu='gpu-name'}";
private String containerRequestGpuMemoryQueryParam = "container_request_gpu_memory{node='node-name',req_of_gpu_memory='gpu-name'}";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类MetricsServiceImpl中有一个名为getQueryRangeParamMap的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private Map<String, Object> getQueryRangeParamMap(String queryParam, Long startTime, Long endTime, Integer step, String nodeName, String dockerDataPath, String gpuName, String podName) {
    Map<String, Object> param = new HashMap<>();
    if (Objects.equals("cpu_use_rate", queryParam)) {
        param = PrometheusUtil.getPodQueryRangeParamMap(cpuUseRateQueryParam, startTime, endTime, step, podName);
    }
    if (Objects.equals("memory_use_rate", queryParam)) {
        param = PrometheusUtil.getPodQueryRangeParamMap(memoryUseRateQueryParam, startTime, endTime, step, podName);
    }
    if (Objects.equals("up_speed", queryParam)) {
        param = PrometheusUtil.getPodQueryRangeParamMap(upSpeedQueryParam, startTime, endTime, step, podName);
    }
    if (Objects.equals("down_speed", queryParam)) {
        param = PrometheusUtil.getPodQueryRangeParamMap(downSpeedQueryParam, startTime, endTime, step, podName);
    }
    if (Objects.equals("gpu_memory_rate", queryParam)) {
        param = PrometheusUtil.getPodQueryRangeParamMap(gpuMemoryRateQueryParam, startTime, endTime, step, podName);
    }
    if (Objects.equals("gpu_utilization_rate", queryParam)) {
        param = PrometheusUtil.getPodQueryRangeParamMap(gpuUtilizationRateQueryParam, startTime, endTime, step, podName);
    }
    //node_cpu_utilisation
    if (Objects.equals("node_cpu_utilisation", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeCpuUtilisation, startTime, endTime, step, nodeName);
    }
    //node_mem_utilisation
    if (Objects.equals("node_mem_utilisation", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeMemUtilisation, startTime, endTime, step, nodeName);
    }
    //node_disk_size_utilisation
    if (Objects.equals("node_disk_size_utilisation", queryParam)) {
        param = PrometheusUtil.getNodeDiskQueryRangeParamMap(nodeDiskSizeUtilisation, startTime, endTime, step, nodeName, dockerDataPath);
    }
    //node_disk_read_io
    if (Objects.equals("node_disk_read_io", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeDiskReadIo, startTime, endTime, step, nodeName);
    }
    //node_disk_write_io
    if (Objects.equals("node_disk_write_io", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeDiskWriteIo, startTime, endTime, step, nodeName);
    }
    //node_network_read_io
    if (Objects.equals("node_network_read_io", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeNetworkReadIo, startTime, endTime, step, nodeName);
    }
    //node_network_write_io
    if (Objects.equals("node_network_write_io", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeNetworkWriteIo, startTime, endTime, step, nodeName);
    }
    //node_gpu_utilization
    if (Objects.equals("node_gpu_utilization", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeGpuUtilization, startTime, endTime, step, nodeName);
    }
    //node_gpu_men_utilization
    if (Objects.equals("node_gpu_men_utilization", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeGpuMenUtilization, startTime, endTime, step, nodeName);
    }
    //node_dev_gpu_men_utilization
    if (Objects.equals("node_dev_gpu_men_utilization", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeDevGpuMenUtilization, startTime, endTime, step, nodeName);
    }
    //node_dev_gpu_men_total_utilization
    if (Objects.equals("node_dev_gpu_men_total_utilization", queryParam)) {
        param = PrometheusUtil.getNodeQueryRangeParamMap(nodeDevGpuMenTotalUtilization, startTime, endTime, step, nodeName);
    }
    //dev_gpu_utilization
    if (Objects.equals("dev_gpu_utilization", queryParam)) {
        param = PrometheusUtil.getNodeGpuQueryRangeParamMap(devGpuUtilization, startTime, endTime, step, nodeName, gpuName);
    }
    //gpu_men_utilization
    if (Objects.equals("gpu_men_utilization", queryParam)) {
        param = PrometheusUtil.getNodeGpuQueryRangeParamMap(gpuMenUtilization, startTime, endTime, step, nodeName, gpuName);
    }
    //dev_gpu_men_utilization
    if (Objects.equals("dev_gpu_men_total_utilization", queryParam)) {
        param = PrometheusUtil.getNodeGpuQueryRangeParamMap(devGpuMenUtilization, startTime, endTime, step, nodeName, gpuName);
    }
    //dev_gpu_men_total_utilization
    if (Objects.equals("dev_gpu_men_utilization", queryParam)) {
        param = PrometheusUtil.getNodeGpuQueryRangeParamMap(devGpuMenTotalUtilization, startTime, endTime, step, nodeName, gpuName);
    }
    return param;
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.util.PrometheusUtil
java.util
### 类级别的变量
private String query = "api/v1/query";
//pod 监控指标
private String cpuUseRateQueryParam = "pod:cpu_utilisation:avg5m{pod='pod-name'}";
private String memoryUseRateQueryParam = "pod:memory_utilisation{pod='pod-name'}";
private String upSpeedQueryParam = "pod:net_bytes_transmitted:avg5m{pod='pod-name'}";
private String downSpeedQueryParam = "pod:net_bytes_received:avg5m{pod='pod-name'}";
private String gpuMemoryRateQueryParam = "(sum by (pod_name,node) (container_gpu_memory_total{pod_name='pod-name',gpu_memory='total'})) / (sum by (pod_name,node) (container_request_gpu_memory{pod_name='pod-name',req_of_gpu_memory='total'})) * 100";
private String gpuUtilizationRateQueryParam = "(sum by (pod_name,node) (container_gpu_utilization{pod_name='pod-name',gpu='total'})) / (sum by (pod_name,node) (container_request_gpu_utilization{pod_name='pod-name',req_of_gpu='total'}))";
//主机 监控指标
private String nodeCpuUtilisation = "(1 - avg(rate(node_cpu_seconds_total{instance=~'node-name.*',mode='idle'}[5m])) by (instance)) * 100";
private String nodeMemUtilisation = "(1 - (node_memory_MemAvailable_bytes{instance=~'node-name.*'} / (node_memory_MemTotal_bytes{instance=~'node-name.*'})))* 100";
private String nodeDiskSizeUtilisation = "(node_filesystem_size_bytes{instance=~'node-name.*',mountpoint='docker-data-path'} - node_filesystem_avail_bytes{instance=~'node-name.*',mountpoint='docker-data-path'})/node_filesystem_size_bytes{instance=~'node-name.*',mountpoint='docker-data-path'} * 100";
private String nodeDiskReadIo = "max(rate(node_disk_read_bytes_total{instance=~'node-name.*'}[5m])) by (instance)";
private String nodeDiskWriteIo = "max(rate(node_disk_written_bytes_total{instance=~'node-name.*'}[5m])) by (instance)";
private String nodeNetworkReadIo = "max(rate(node_network_transmit_bytes_total{instance=~'node-name.*'}[5m])*8) by (instance)";
private String nodeNetworkWriteIo = "max(rate(node_network_receive_bytes_total{instance=~'node-name.*'}[5m])*8) by (instance)";
private String nodeGpuUtilization = "sum by (node) (dev_gpu_utilization{node='node-name'}) / count by (node) (dev_gpu_utilization{node='node-name'})";
private String nodeGpuMenUtilization = "(sum by (node) (node_gpu_memory_used{node='node-name'})) / (sum by (node) (node_gpu_memory_total{node='node-name'})) * 100";
private String nodeDevGpuMenUtilization = "(sum by (node)(dev_gpu_memory{node='node-name'})) / (sum by (node) (node_gpu_memory_total{node='node-name'})) * 100";
private String nodeDevGpuMenTotalUtilization = "(sum by (node)(dev_gpu_memory_total{node='node-name'})) / (sum by (node) (node_gpu_memory_total{node='node-name'})) * 100";
//GPU设备 监控指标
private String devGpuUtilization = "dev_gpu_utilization{node='node-name',gpu='gpu-name'}";
private String gpuMenUtilization = "(sum by (node,gpu) (node_gpu_memory_used{node='node-name',gpu='gpu-name'})) / (sum by (node,gpu) (node_gpu_memory_total{node='node-name',gpu='gpu-name'})) * 100";
private String devGpuMenUtilization = "(sum by (node,gpu)(dev_gpu_memory{node='node-name',gpu='gpu-name'})) / (sum by (node,gpu) (node_gpu_memory_total{node='node-name',gpu='gpu-name'})) * 100";
private String devGpuMenTotalUtilization = "(sum by (node,gpu)(dev_gpu_memory_total{node='node-name',gpu='gpu-name'})) / (sum by (node,gpu) (node_gpu_memory_total{node='node-name',gpu='gpu-name'})) * 100";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类NamespaceServiceImpl中有一个名为createNamespace的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public NamespaceBo createNamespace(String clusterName, String namespace) throws Exception {
    log.info("NamespaceServiceImpl.createNamespace：{}", namespace);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1Namespace body = new V1Namespace().metadata(new V1ObjectMeta().name(namespace));
        api.createNamespace(body, null, null, null);
        V1Namespace resource = api.readNamespace(namespace, null);
        return namespaceConvert.mappingTo(resource);
    } catch (Throwable e) {
        throw new TrainginCenterException("创建命名空间失败:" + e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.NamespaceService
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Namespace
io.kubernetes.client.openapi.models.V1ObjectMeta
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private NamespaceConvert namespaceConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类NamespaceServiceImpl中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public NamespaceBo get(String clusterName, String namespace) throws Exception {
    log.info("NamespaceServiceImpl.get：{},{}", clusterName, namespace);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1Namespace resource = api.readNamespace(namespace, null);
        return namespaceConvert.mappingTo(resource);
    } catch (ApiException e) {
        if (e.getCode() == 404) {
            return null;
        }
        throw new TrainginCenterException("查询命名空间失败:" + e.getMessage());
    } catch (Throwable e) {
        throw new TrainginCenterException("查询命名空间失败:" + e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.NamespaceService
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Namespace
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private NamespaceConvert namespaceConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类NamespaceServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(String clusterName, String namespace) {
    log.info("NamespaceServiceImpl.delete params: [{},{}]", clusterName, namespace);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        api.deleteNamespace(namespace, null, null, null, null, null, null);
        return RestResult.genSuccessResult("删除命名空间成功", null);
    } catch (Exception e) {
        return RestResult.genFailResult(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.k8s.service.NamespaceService
io.kubernetes.client.openapi.apis.CoreV1Api
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类NamespaceServiceImpl中有一个名为countNamespaceResourceInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public NamespaceResourceInfoVo countNamespaceResourceInfo(String cluster, String namespace) throws Exception {
    NamespaceResourceInfoVo vo = new NamespaceResourceInfoVo();
    List<ResourceQuotaBo> resourceQuotaBoList = resourceQuotaService.list(cluster, namespace);
    if (CollectionUtil.isNotEmpty(resourceQuotaBoList)) {
        // 获取资源配额信息
        // cpu核数
        QuantityBo hardCpu = resourceQuotaBoList.get(0).getHard().get(K8sConstant.RESOURCE_QUOTA_CPU_LIMITS_KEY);
        if (hardCpu != null) {
            vo.setHardCpu(UnitConvertUtils.cpuFormatToCore(hardCpu.getAmount(), hardCpu.getFormat()));
        }
        QuantityBo usedCpu = resourceQuotaBoList.get(0).getUsed().get(K8sConstant.RESOURCE_QUOTA_CPU_LIMITS_KEY);
        if (usedCpu != null) {
            vo.setUsedCpu(UnitConvertUtils.cpuFormatToCore(usedCpu.getAmount(), usedCpu.getFormat()));
        }
        //内存
        QuantityBo hardMemory = resourceQuotaBoList.get(0).getHard().get(K8sConstant.RESOURCE_QUOTA_MEMORY_LIMITS_KEY);
        if (hardMemory != null) {
            vo.setHardMemory(UnitConvertUtils.memFormatToGi(hardMemory.getAmount(), hardMemory.getFormat()));
        }
        QuantityBo usedMemory = resourceQuotaBoList.get(0).getUsed().get(K8sConstant.RESOURCE_QUOTA_MEMORY_LIMITS_KEY);
        if (usedMemory != null) {
            vo.setUsedMemory(UnitConvertUtils.memFormatToGi(usedMemory.getAmount(), usedMemory.getFormat()));
        }
        //gpu核数
        QuantityBo hardGpuCore = resourceQuotaBoList.get(0).getHard().get(K8sConstant.RESOURCE_QUOTA_GPU_CORE_REQUESTS_KEY);
        if (hardGpuCore != null) {
            vo.setHardGpuCore(Long.valueOf(hardGpuCore.getAmount()));
        }
        QuantityBo usedGpuCore = resourceQuotaBoList.get(0).getUsed().get(K8sConstant.RESOURCE_QUOTA_GPU_CORE_REQUESTS_KEY);
        if (usedGpuCore != null) {
            vo.setUsedGpuCore(Long.valueOf(usedGpuCore.getAmount()));
        }
        // gpu显存
        QuantityBo hardGpuMem = resourceQuotaBoList.get(0).getHard().get(K8sConstant.RESOURCE_QUOTA_GPU_MEMORY_REQUESTS_KEY);
        if (hardGpuMem != null) {
            vo.setHardGpuMemory(UnitConvertUtils.gpuMemoryFormatToM(hardGpuMem.getAmount(), hardGpuMem.getFormat()));
        }
        QuantityBo usedGpuMem = resourceQuotaBoList.get(0).getUsed().get(K8sConstant.RESOURCE_QUOTA_GPU_MEMORY_REQUESTS_KEY);
        if (usedGpuMem != null) {
            vo.setUsedGpuMemory(UnitConvertUtils.gpuMemoryFormatToM(usedGpuMem.getAmount(), usedGpuMem.getFormat()));
        }
        // gpu数量
        QuantityBo hardGpu = resourceQuotaBoList.get(0).getUsed().get(K8sConstant.RESOURCE_QUOTA_GPU_REQUESTS_KEY);
        if (hardGpu != null) {
            vo.setHardGpu(Long.valueOf(hardGpu.getAmount()));
        }
        QuantityBo usedGpu = resourceQuotaBoList.get(0).getUsed().get(K8sConstant.RESOURCE_QUOTA_GPU_REQUESTS_KEY);
        if (usedGpu != null) {
            vo.setUsedGpu(Long.valueOf(usedGpu.getAmount()));
        }
    }
    HashMap<String, PodResourceInfoVo> bizUsed = new HashMap<>();
    List<PodBo> podBoList = podService.list(cluster, namespace);
    if (CollectionUtil.isNotEmpty(podBoList)) {
        //按照业务标签分组
        HashMap<String, List<PodBo>> podGroup = podService.groupByBizLabel(podBoList);
        //各业务资源占用情况
        for (Map.Entry<String, List<PodBo>> entry : podGroup.entrySet()) {
            String bizLabel = entry.getKey();
            log.info("占用资源分类: {}", bizLabel);
            PodResourceInfoVo resourceInfoVo = podService.countPodResourceInfo(entry.getValue());
            log.info("bizLabel:{},cpu:{},memory:{},gpuCore:{},gpuMemory:{},gpu:{}", bizLabel, resourceInfoVo.getCpu(), resourceInfoVo.getMemory(), resourceInfoVo.getGpuCore(), resourceInfoVo.getGpuMemory(), resourceInfoVo.getGpu());
            bizUsed.put(bizLabel, resourceInfoVo);
        }
    }
    vo.setBizUsed(bizUsed);
    return vo;
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.eshore.gdai.trainingcenter.k8s.constant.K8sConstant
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.QuantityBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.ResourceQuotaBo
com.eshore.gdai.trainingcenter.k8s.domain.vo.NamespaceResourceInfoVo
com.eshore.gdai.trainingcenter.k8s.domain.vo.PodResourceInfoVo
com.eshore.gdai.trainingcenter.util.UnitConvertUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.HashMap
java.util.List
java.util.Map
### 类级别的变量
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private PodService podService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类NodeServiceImpl中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public NodeBo get(String clusterName, String nodeName) throws Exception {
    log.info("NodeServiceImpl.get params: [{},{}]", clusterName, nodeName);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1Node node = api.readNode(nodeName, null);
        return nodeConvert.mappingTo(node);
    } catch (Exception e) {
        throw new TrainginCenterException("获取节点信息失败！" + e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.NodeService
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Node
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private NodeConvert nodeConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类NodeServiceImpl中有一个名为list的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<NodeBo> list(String clusterName) throws Exception {
    log.info("NodeServiceImpl.list params: [{}]", clusterName);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1NodeList nodeList = api.listNode(null, null, null, null, null, null, null, null, null, null);
        //            log.info(JSONObject.toJSONString(nodeList));
        // 转换成业务对象
        return nodeList.getItems().parallelStream().map(item -> nodeConvert.mappingTo(item)).collect(Collectors.toList());
    } catch (Exception e) {
        throw new TrainginCenterException("获取节点资源信息失败！" + e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.NodeService
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Node
io.kubernetes.client.openapi.models.V1NodeList
org.springframework.stereotype.Service
java.util.List
java.util.stream.Collectors
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private NodeConvert nodeConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类NodeServiceImpl中有一个名为countNodeResourceInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public NodeResourceInfoVo countNodeResourceInfo(String clusterName, String nodeName) throws Exception {
    log.info("NodeServiceImpl.countNodeResourceInfo params: [{},{}]", clusterName, nodeName);
    try {
        NodeBo node = get(clusterName, nodeName);
        NodeResourceInfoVo info = new NodeResourceInfoVo();
        // 获取资源配额信息
        // cpu核数
        QuantityBo cpu = node.getAllocatable().get(K8sConstant.RESOURCE_CPU_KEY);
        if (cpu != null) {
            info.setCpu(UnitConvertUtils.cpuFormatToCore(cpu.getAmount(), cpu.getFormat()));
        }
        // 内存大小
        QuantityBo memory = node.getAllocatable().get(K8sConstant.RESOURCE_MEMORY_KEY);
        if (memory != null) {
            info.setMemory(UnitConvertUtils.memFormatToGi(memory.getAmount(), memory.getFormat()));
        }
        // gpu核数
        QuantityBo gpuCore = node.getAllocatable().get(K8sConstant.RESOURCE_GPU_CORE_KEY);
        if (gpuCore != null) {
            info.setGpuCore(Long.valueOf(gpuCore.getAmount()));
        }
        // gpu显存大小
        QuantityBo gpuMem = node.getAllocatable().get(K8sConstant.RESOURCE_GPU_MEMORY_KEY);
        if (gpuMem != null) {
            info.setGpuMemory(UnitConvertUtils.gpuMemoryFormatToM(gpuMem.getAmount(), gpuMem.getFormat()));
        }
        // gpu
        QuantityBo gpu = node.getAllocatable().get(K8sConstant.RESOURCE_GPU_KEY);
        if (gpu != null) {
            info.setGpu(Long.valueOf(gpu.getAmount()));
        }
        // 存储
        info.setStorage(0L);
        //
        //            Map<String, String> labels = LabelUtils.addBizEnvLabel(null);
        // 获取已分配资源信息
        List<PodBo> podBoList = podService.listByNodeName(clusterName, nodeName);
        HashMap<String, PodResourceInfoVo> bizUsed = new HashMap<>();
        if (CollectionUtil.isNotEmpty(podBoList)) {
            //按照业务标签分组
            HashMap<String, List<PodBo>> podGroup = podService.groupByBizLabel(podBoList);
            //各业务资源占用情况
            for (Map.Entry<String, List<PodBo>> entry : podGroup.entrySet()) {
                String bizLabel = entry.getKey();
                PodResourceInfoVo resourceInfoVo = podService.countPodResourceInfo(entry.getValue());
                log.info("bizLabel:{},cpu:{},memory:{},gpuCore:{},gpuMemory:{},gpu:{}", bizLabel, resourceInfoVo.getCpu(), resourceInfoVo.getMemory(), resourceInfoVo.getGpuCore(), resourceInfoVo.getGpuMemory(), resourceInfoVo.getGpu());
                bizUsed.put(bizLabel, resourceInfoVo);
            }
        }
        info.setBizUsed(bizUsed);
        return info;
    } catch (Exception e) {
        throw new TrainginCenterException("获取节点资源信息失败！" + e.getMessage());
    }
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.constant.K8sConstant
com.eshore.gdai.trainingcenter.k8s.domain.bo.NodeBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.QuantityBo
com.eshore.gdai.trainingcenter.k8s.domain.vo.NodeResourceInfoVo
com.eshore.gdai.trainingcenter.k8s.domain.vo.PodResourceInfoVo
com.eshore.gdai.trainingcenter.k8s.service.NodeService
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
com.eshore.gdai.trainingcenter.util.UnitConvertUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.HashMap
java.util.List
java.util.Map
### 类级别的变量
@Resource
private PodService podService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据Pod名称和命名空间查询Pod
     *
     * @param namespace 命名空间
     * @param podName   Pod名称
     * @return PodBo Pod业务类
     */
public PodBo get(String clusterName, String namespace, String podName) throws Exception {
    log.info("PodApiServiceImpl.get params: [{},{},{}]", clusterName, namespace, podName);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1Pod pod = api.readNamespacedPod(podName, namespace, "true");
        //            log.info(JSONObject.toJSONString(pod));
        return podConvert.mappingTo(pod);
    } catch (ApiException e) {
        if (e.getCode() == 404) {
            return null;
        }
        throw new TrainginCenterException("查询Pod失败:" + e.getMessage());
    } catch (Throwable e) {
        throw new TrainginCenterException("查询Pod失败:" + e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private PodConvert podConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为listAll的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//TBD 区分生产和测试
public List<PodBo> listAll(String clusterName, String labelSelector) throws Exception {
    log.info("PodApiServiceImpl.listAll params: [{}]", clusterName);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1PodList podList = api.listPodForAllNamespaces(null, null, null, labelSelector, null, null, null, null, null, null);
        return convert(podList);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为list的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<PodBo> list(String clusterName, String nameSpace, Map<String, String> labels) throws Exception {
    log.info("PodApiServiceImpl.listAll params: [{},{},{}]", clusterName, nameSpace, labels);
    try {
        String labelSelector = null;
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        if (CollectionUtil.isNotEmpty(labels)) {
            labelSelector = convertLabelsToString(labels);
        }
        V1PodList podList = api.listNamespacedPod(nameSpace, null, null, null, null, labelSelector, null, null, null, null, null);
        return convert(podList);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.chinatelecom.dcoos.common.exception.TrainginCenterException
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为listByNodeName的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<PodBo> listByNodeName(String clusterName, String nodeName, Map<String, String> labels) throws Exception {
    log.info("PodApiServiceImpl.listByNodeName params: [{},{},{}]", clusterName, nodeName, labels);
    try {
        String labelSelector = null;
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        if (CollectionUtil.isNotEmpty(labels)) {
            labelSelector = convertLabelsToString(labels);
        }
        V1PodList podList = api.listPodForAllNamespaces(null, null, "spec.nodeName=" + nodeName, labelSelector, null, null, null, null, null, null);
        return convert(podList);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.chinatelecom.dcoos.common.exception.TrainginCenterException
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为groupByBizLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public HashMap<String, List<PodBo>> groupByBizLabel(List<PodBo> podList) throws TrainginCenterException {
    if (CollectionUtil.isEmpty(podList)) {
        throw new TrainginCenterException("podList is empty!");
    }
    HashMap<String, List<PodBo>> result = new HashMap<>();
    for (PodBo podBo : podList) {
        Map<String, String> labels = podBo.getLabels();
        String bizLabel = "unknown";
        //根据标签中的biz值进行分组
        if (labels != null && labels.containsKey("biz") && labels.containsKey("bizEnv")) {
            //不是当前运行环境，则分到unknown分组下面
            //现在生产测试共用k8s, 对于主机就当做系统占用，对于命名空间不会出现不同运行环境
            if (Objects.equals(labels.get("bizEnv"), serverMode)) {
                bizLabel = labels.get("biz");
            }
        }
        if (result.containsKey(bizLabel)) {
            result.get(bizLabel).add(podBo);
        } else {
            List<PodBo> list = new ArrayList<>();
            list.add(podBo);
            result.put(bizLabel, list);
        }
    }
    return result;
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
### 类级别的变量
@Value("${config.serverMode}")
private String serverMode;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为countPodResourceInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public PodResourceInfoVo countPodResourceInfo(List<PodBo> podList) throws TrainginCenterException {
    PodResourceInfoVo resourceInfoVo = new PodResourceInfoVo();
    Long cpu = 0L;
    Long memory = 0L;
    Long gpuCore = 0L;
    Long gpuMemory = 0L;
    Long gpu = 0L;
    Long storage = 0L;
    if (CollectionUtil.isNotEmpty(podList)) {
        for (PodBo podBo : podList) {
            for (ContainerBo containerBo : podBo.getContainers()) {
                //不是Succeeded的才统计资源占用
                if (!Objects.equals("Succeeded", podBo.getPhase()) && !Objects.equals("Failed", podBo.getPhase())) {
                    if (containerBo.getLimits() != null) {
                        log.info("占用资源：{}", podBo.getName());
                        //统计cpu资源占用
                        QuantityBo cpuQuantityBo = containerBo.getLimits().get(K8sConstant.RESOURCE_CPU_KEY);
                        if (cpuQuantityBo != null) {
                            cpu += UnitConvertUtils.cpuFormatToCore(cpuQuantityBo.getAmount(), cpuQuantityBo.getFormat());
                        }
                        //统计内存资源占用
                        QuantityBo memoryQuantityBo = containerBo.getLimits().get(K8sConstant.RESOURCE_MEMORY_KEY);
                        if (memoryQuantityBo != null) {
                            memory += UnitConvertUtils.memFormatToGi(memoryQuantityBo.getAmount(), memoryQuantityBo.getFormat());
                        }
                        //统计gpu core资源占用
                        QuantityBo gpuCoreQuantityBo = containerBo.getLimits().get(K8sConstant.RESOURCE_GPU_CORE_KEY);
                        if (gpuCoreQuantityBo != null) {
                            gpuCore += Long.parseLong(gpuCoreQuantityBo.getAmount());
                        }
                        //统计gpu memory资源占用
                        QuantityBo gpuMemoryQuantityBo = containerBo.getLimits().get(K8sConstant.RESOURCE_GPU_MEMORY_KEY);
                        if (gpuMemoryQuantityBo != null) {
                            gpuMemory += UnitConvertUtils.gpuMemoryFormatToM(gpuMemoryQuantityBo.getAmount(), gpuMemoryQuantityBo.getFormat());
                        }
                        //统计gpu资源占用
                        QuantityBo gpuQuantityBo = containerBo.getLimits().get(K8sConstant.RESOURCE_GPU_KEY);
                        if (gpuQuantityBo != null) {
                            gpu += Long.parseLong(gpuQuantityBo.getAmount());
                        }
                        //统计storage资源占用 TBD
                    }
                }
            }
        }
    }
    resourceInfoVo.setCpu(cpu);
    resourceInfoVo.setMemory(memory);
    resourceInfoVo.setGpuCore(gpuCore);
    resourceInfoVo.setGpuMemory(gpuMemory);
    resourceInfoVo.setGpu(gpu);
    resourceInfoVo.setStorage(storage);
    return resourceInfoVo;
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.eshore.gdai.trainingcenter.k8s.constant.K8sConstant
com.eshore.gdai.trainingcenter.k8s.domain.bo.ContainerBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.QuantityBo
com.eshore.gdai.trainingcenter.k8s.domain.vo.PodResourceInfoVo
com.eshore.gdai.trainingcenter.util.UnitConvertUtils
javax.annotation.Resource
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为waitForPodToRuning的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public PodBo waitForPodToRuning(String clusterName, String namespace, String labelSelector, Integer timeoutSeconds) throws Exception {
    CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
    ApiClient apiClient = k8sClientOperator.getK8sClient(clusterName);
    Watch<V1Pod> watch = Watch.createWatch(apiClient, api.listNamespacedPodCall(namespace, null, null, null, null, labelSelector, null, null, null, timeoutSeconds, true, null), new TypeToken<Watch.Response<V1Pod>>() {
    }.getType());
    try {
        for (Watch.Response<V1Pod> item : watch) {
            PodBo podBo = podConvert.mappingTo(item.object);
            if (podBo != null && "Running".equalsIgnoreCase(podBo.getPodFinalPhase())) {
                return podBo;
            }
        }
        return null;
    } finally {
        watch.close();
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
com.google.gson.reflect.TypeToken
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.util.Watch
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private PodConvert podConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类PodServiceImpl中有一个名为readNamespacedPodLog的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String readNamespacedPodLog(String clusterName, String namespace, String podName) throws TrainginCenterException {
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        return api.readNamespacedPodLog(podName, namespace, null, null, null, null, null, null, null, null, null);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
io.kubernetes.client.openapi.apis.CoreV1Api
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ResourceQuotaServiceImpl中有一个名为create的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ResourceQuotaBo create(String clusterName, String namespace, String name, Long cpu, Long memory, Long gpuCore, Long gpuMemory, Long gpu) throws Exception {
    log.info("ResourceQuotaServiceImpl.create params: [{}],[{}],[{}],[{}],[{}],[{}],[{}],[{}]", clusterName, namespace, name, cpu, memory, gpuCore, gpuMemory, gpu);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        // 读取模板文件
        String ymlContentResourceQuota = k8sClientOperator.getYamlFile("ResourceQuota.yaml");
        // 给模板的变量设置实际值
        JSONObject context = new JSONObject();
        context.put("name", name);
        context.put("cpu", cpu);
        context.put("memory", memory);
        if (gpuCore != null) {
            context.put("gpuCore", gpuCore);
        }
        if (gpuMemory != null) {
            context.put("gpuMemory", gpuMemory);
        }
        if (gpu != null) {
            context.put("gpu", gpu);
        }
        // 使用模板引擎生成实际的yaml文件内容，并解析为对象
        V1ResourceQuota resourceQuota = YamlUtil.loadObject(ymlContentResourceQuota, context, V1ResourceQuota.class);
        String yamlresourceQuotaStr = io.kubernetes.client.util.Yaml.dump(resourceQuota);
        log.info(yamlresourceQuotaStr);
        // 创建资源配额
        api.createNamespacedResourceQuota(namespace, resourceQuota, null, null, null);
        // 查看创建结果
        resourceQuota = api.readNamespacedResourceQuota(name, namespace, "true");
        log.info(JSONObject.toJSONString(resourceQuota));
        // 转换成业务对象
        return resourceQuotaConvert.mappingTo(resourceQuota);
    } catch (Exception e) {
        throw new TrainginCenterException("创建资源配额失败：" + e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.ResourceQuotaService
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1ResourceQuota
org.springframework.stereotype.Service
javax.annotation.Resource
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private ResourceQuotaConvert resourceQuotaConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ResourceQuotaServiceImpl中有一个名为patch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ResourceQuotaBo patch(String clusterName, String namespace, String name, Long cpu, Long memory, Long gpuCore, Long gpuMemory, Long gpu) throws Exception {
    log.info("ResourceQuotaServiceImpl.patch params: [{}],[{}],[{}],[{}],[{}],[{}],[{}],[{}]", clusterName, namespace, name, cpu, memory, gpuCore, gpuMemory, gpu);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        // 获取资源配额列表
        V1ResourceQuota currentResourceQuota = api.readNamespacedResourceQuota(name, namespace, null);
        // 转换成业务对象
        ResourceQuotaBo resourceQuotaBo = resourceQuotaConvert.mappingTo(currentResourceQuota);
        log.info("当前资源配额：[{}]", JSONObject.toJSONString(resourceQuotaBo));
        // cpu核数
        QuantityBo hardCpu = resourceQuotaBo.getHard().get(K8sConstant.RESOURCE_QUOTA_CPU_LIMITS_KEY);
        Long currentCpu = 0L;
        if (hardCpu != null) {
            currentCpu = UnitConvertUtils.cpuFormatToCore(hardCpu.getAmount(), hardCpu.getFormat());
        }
        // memory大小
        QuantityBo hardMemory = resourceQuotaBo.getHard().get(K8sConstant.RESOURCE_QUOTA_MEMORY_LIMITS_KEY);
        Long currentMemory = 0L;
        if (hardMemory != null) {
            currentMemory = UnitConvertUtils.memFormatToMi(hardMemory.getAmount(), hardMemory.getFormat());
        }
        // gpu核数
        QuantityBo hardGpuCore = resourceQuotaBo.getHard().get(K8sConstant.RESOURCE_QUOTA_GPU_CORE_REQUESTS_KEY);
        Long currentGpuCore = 0L;
        if (hardGpuCore != null) {
            currentGpuCore = Long.valueOf(hardGpuCore.getAmount());
        }
        // gpu内存大小
        QuantityBo hardGpuMem = resourceQuotaBo.getHard().get(K8sConstant.RESOURCE_QUOTA_GPU_MEMORY_REQUESTS_KEY);
        Long currentGpuMemory = 0L;
        if (hardGpuMem != null) {
            currentGpuMemory = UnitConvertUtils.gpuMemoryFormatToM(hardGpuMem.getAmount(), hardGpuMem.getFormat());
        }
        // gpu数量
        QuantityBo hardGpu = resourceQuotaBo.getHard().get(K8sConstant.RESOURCE_QUOTA_GPU_REQUESTS_KEY);
        Long currentGpu = 0L;
        if (hardGpu != null) {
            currentGpu = Long.valueOf(hardGpu.getAmount());
        }
        String pathLimits = "/spec/hard/limits.";
        String pathRequests = "/spec/hard/requests.";
        JSONArray jsonPatchArray = new JSONArray();
        if (cpu != null && currentCpu != 0L && !currentCpu.equals(cpu)) {
            // 调用方法添加关于CPU的patch
            addPatchOperation(jsonPatchArray, pathLimits + K8sConstant.RESOURCE_CPU_KEY, String.valueOf(cpu));
            addPatchOperation(jsonPatchArray, pathRequests + K8sConstant.RESOURCE_CPU_KEY, String.valueOf(cpu));
        }
        if (memory != null && currentMemory != 0L && !currentMemory.equals(memory)) {
            // 调用方法添加关于Memory的patch
            addPatchOperation(jsonPatchArray, pathLimits + K8sConstant.RESOURCE_MEMORY_KEY, memory + "Mi");
            addPatchOperation(jsonPatchArray, pathRequests + K8sConstant.RESOURCE_MEMORY_KEY, memory + "Mi");
        }
        if (gpuCore != null && currentGpuCore != 0L && !currentGpuCore.equals(gpuCore)) {
            // 调用方法添加关于GPU核心数的patch
            addPatchOperation(jsonPatchArray, pathLimits + K8sConstant.RESOURCE_GPU_CORE_KEY_ENCODED, String.valueOf(gpuCore));
            addPatchOperation(jsonPatchArray, pathRequests + K8sConstant.RESOURCE_GPU_CORE_KEY_ENCODED, String.valueOf(gpuCore));
        }
        if (gpuMemory != null && currentGpuMemory != 0L && !currentGpuMemory.equals(gpuMemory)) {
            // 调用方法添加关于GPU内存大小的patch
            addPatchOperation(jsonPatchArray, pathLimits + K8sConstant.RESOURCE_GPU_MEMORY_KEY_ENCODED, gpuMemory);
            addPatchOperation(jsonPatchArray, pathRequests + K8sConstant.RESOURCE_GPU_MEMORY_KEY_ENCODED, gpuMemory);
        }
        if (gpu != null && currentGpu != 0L && !currentGpu.equals(gpu)) {
            // 调用方法添加关于GPU数量的patch
            addPatchOperation(jsonPatchArray, pathLimits + K8sConstant.RESOURCE_GPU_KEY_ENCODED, String.valueOf(gpu));
            addPatchOperation(jsonPatchArray, pathRequests + K8sConstant.RESOURCE_GPU_KEY_ENCODED, String.valueOf(gpu));
        }
        log.info("patch的请求数据: {}", jsonPatchArray.toJSONString());
        V1Patch body = new V1Patch(jsonPatchArray.toJSONString());
        V1ResourceQuota resourceQuota = api.patchNamespacedResourceQuota(name, namespace, body, null, null, null, null);
        // 转换成业务对象
        return resourceQuotaConvert.mappingTo(resourceQuota);
    } catch (Exception e) {
        throw new TrainginCenterException("更新资源配额失败：" + e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.constant.K8sConstant
com.eshore.gdai.trainingcenter.k8s.domain.bo.QuantityBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.ResourceQuotaBo
com.eshore.gdai.trainingcenter.k8s.service.ResourceQuotaService
com.eshore.gdai.trainingcenter.util.UnitConvertUtils
io.kubernetes.client.custom.V1Patch
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1ResourceQuota
org.springframework.stereotype.Service
javax.annotation.Resource
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private ResourceQuotaConvert resourceQuotaConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ResourceQuotaServiceImpl中有一个名为list的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<ResourceQuotaBo> list(String clusterName, String namespace) throws Exception {
    log.info("ResourceQuotaServiceImpl.list params: [{},{}]", clusterName, namespace);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        // 获取资源配额列表
        V1ResourceQuotaList resourceQuotaList = api.listNamespacedResourceQuota(namespace, "true", null, null, null, null, null, null, null, null, null);
        log.info(JSONObject.toJSONString(resourceQuotaList));
        // 转换成业务对象
        return resourceQuotaList.getItems().parallelStream().map(item -> resourceQuotaConvert.mappingTo(item)).collect(Collectors.toList());
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.ResourceQuotaService
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1ResourceQuota
io.kubernetes.client.openapi.models.V1ResourceQuotaList
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.List
java.util.stream.Collectors
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private ResourceQuotaConvert resourceQuotaConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ResourceQuotaServiceImpl中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ResourceQuotaBo get(String clusterName, String namespace, String name) throws Exception {
    log.info("ResourceQuotaServiceImpl.list params: [{},{}]", clusterName, namespace);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        // 获取资源配额列表
        V1ResourceQuota resourceQuota = api.readNamespacedResourceQuota(name, namespace, null);
        log.info(JSONObject.toJSONString(resourceQuota));
        // 转换成业务对象
        return resourceQuotaConvert.mappingTo(resourceQuota);
    } catch (ApiException e) {
        if (e.getCode() == 404) {
            return null;
        }
        throw new TrainginCenterException("查询配额失败:" + e.getMessage());
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.ResourceQuotaService
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1ResourceQuota
org.springframework.stereotype.Service
javax.annotation.Resource
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private ResourceQuotaConvert resourceQuotaConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ResourceQuotaServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(String clusterName, String namespace, String name) {
    log.info("ResourceQuotaServiceImpl.delete params: [{},{}]", clusterName, namespace);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        api.deleteNamespacedResourceQuota(name, namespace, null, null, null, null, null, null);
        return RestResult.genSuccessResult("删除配额成功", null);
    } catch (Exception e) {
        return RestResult.genFailResult(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.k8s.service.ResourceQuotaService
io.kubernetes.client.openapi.apis.CoreV1Api
org.springframework.stereotype.Service
javax.annotation.Resource
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ResourceQuotaServiceImpl中有一个名为reachLimitsOfResources的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult reachLimitsOfResources(String clusterName, String namespace, Integer cpu, Integer memory, Integer gpuCore, Integer gpuMemory, Integer gpu) throws Exception {
    List<ResourceQuotaBo> resourceQuotas = list(clusterName, namespace);
    // 如果没有设置资源配额，则直接返回成功
    if (CollectionUtils.isEmpty(resourceQuotas)) {
        return RestResult.genSuccessResult("资源充足");
    }
    // 判断是否达到了资源限制
    for (ResourceQuotaBo resourceQuota : resourceQuotas) {
        Map<String, QuantityBo> freeResource = resourceQuota.getFreeResource();
        // 申请的cpu超出佘量
        QuantityBo freeCpu = freeResource.get(K8sConstant.RESOURCE_QUOTA_CPU_LIMITS_KEY);
        if (freeCpu != null && Integer.parseInt(freeCpu.getAmount()) <= cpu) {
            return RestResult.genFailResult("cpu用量超限");
        }
        // 申请的内存超出佘量
        QuantityBo freeMemory = freeResource.get(K8sConstant.RESOURCE_QUOTA_MEMORY_LIMITS_KEY);
        if (freeMemory != null && Integer.parseInt(freeMemory.getAmount()) <= memory) {
            return RestResult.genFailResult("内存用量超限");
        }
        // 申请的GPU核数超出佘量
        QuantityBo freeGpuCore = freeResource.get(K8sConstant.RESOURCE_QUOTA_GPU_CORE_REQUESTS_KEY);
        if (freeGpuCore != null && Integer.parseInt(freeGpuCore.getAmount()) <= gpuCore) {
            return RestResult.genFailResult("GPU核数用量超限");
        }
        // 申请的GPU内存超出佘量
        QuantityBo freeGpuMemory = freeResource.get(K8sConstant.RESOURCE_QUOTA_GPU_MEMORY_REQUESTS_KEY);
        if (freeGpuMemory != null && Integer.parseInt(freeGpuMemory.getAmount()) <= gpuMemory) {
            return RestResult.genFailResult("GPU内存用量超限");
        }
        // 申请的GPU核数超出佘量
        QuantityBo freeGpu = freeResource.get(K8sConstant.RESOURCE_QUOTA_GPU_REQUESTS_KEY);
        if (freeGpuCore != null && Integer.parseInt(freeGpuCore.getAmount()) <= gpu) {
            return RestResult.genFailResult("GPU数用量超限");
        }
    }
    return RestResult.genSuccessResult("资源充足");
}
### 类导入的包
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.k8s.constant.K8sConstant
com.eshore.gdai.trainingcenter.k8s.domain.bo.QuantityBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.ResourceQuotaBo
org.springframework.util.CollectionUtils
javax.annotation.Resource
java.util.List
java.util.Map
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ResourceQuotaServiceImpl中有一个名为addPatchOperation的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private void addPatchOperation(JSONArray jsonPatchArray, String path, Object value) {
    if (value != null) {
        JSONObject patch = new JSONObject();
        patch.put("op", "replace");
        patch.put("path", path);
        patch.put("value", value);
        jsonPatchArray.add(patch);
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类SecretServiceImpl中有一个名为createDockerconfigSecret的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void createDockerconfigSecret(String clusterName, String namespace, String name, String hubUrl, String secretName, String secretPwd, String email) throws Exception {
    log.info("SecretServiceImpl.create params:{}, {}, {}, {}, {},{},{}", clusterName, namespace, name, hubUrl, secretName, secretPwd, email);
    CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
    String authStr = secretName + ":" + secretPwd;
    authStr = Base64.getEncoder().encodeToString(authStr.getBytes());
    JSONObject auth = new JSONObject();
    auth.put("username", secretName);
    auth.put("password", secretPwd);
    auth.put("email", email);
    auth.put("auth", authStr);
    JSONObject auths = new JSONObject();
    auths.put(hubUrl, auth);
    JSONObject secretJson = new JSONObject();
    secretJson.put("auths", auths);
    log.info("SecretServiceImpl.create secretJson:{}", secretJson.toJSONString());
    V1Secret secret = new V1SecretBuilder().withType("kubernetes.io/dockerconfigjson").withNewMetadata().withName(name).endMetadata().addToStringData(".dockerconfigjson", secretJson.toJSONString()).build();
    api.createNamespacedSecret(namespace, secret, null, null, null);
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.k8s.service.SecretService
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Secret
io.kubernetes.client.openapi.models.V1SecretBuilder
org.springframework.stereotype.Service
java.util.Base64
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ServiceServiceImpl中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ServiceBo get(String clusterName, String namespace, String serviceName) throws Exception {
    log.info("ServiceServiceImpl.get params: [{},{}]", clusterName, serviceName);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1Service service = api.readNamespacedService(serviceName, namespace, null);
        return serviceConvert.mappingTo(service);
    } catch (Exception e) {
        throw new TrainginCenterException("获取服务信息失败！" + e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.ServiceService
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Service
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private ServiceConvert serviceConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ServiceServiceImpl中有一个名为createService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ServiceBo createService(String clusterName, String namespace, V1Service body) throws Exception {
    log.info("ServiceServiceImpl.createService params: [clusterName={},namespace={}]", clusterName, namespace);
    try {
        CoreV1Api api = k8sClientOperator.getCoreV1Api(clusterName);
        V1Service v1Service = api.createNamespacedService(namespace, body, null, null, null);
        return serviceConvert.mappingTo(v1Service);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.ServiceService
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Service
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private ServiceConvert serviceConvert;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.service.impl下的类ServiceServiceImpl中有一个名为createService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ServiceBo createService(String clusterName, String namespace, String yamlContent) throws Exception {
    log.info("ServiceServiceImpl.createService params: [clusterName={},namespace={},yamlContent={}]", clusterName, namespace, yamlContent);
    try {
        V1Service service = YamlUtil.loadK8sObject(yamlContent, "Service", V1Service.class);
        return createService(clusterName, namespace, service);
    } catch (Exception e) {
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.k8s.service.ServiceService
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.models.V1Service
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.util下的类PrometheusUtil中有一个名为getQuery的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static PrometheusMetricBo getQuery(String url, Map<String, Object> paramMap) {
    if (StringUtils.isEmpty(url)) {
        return null;
    }
    try {
        String metricStr = HttpUtil.get(url, paramMap);
        if (StringUtils.isEmpty(metricStr)) {
            return null;
        }
        return JSON.parseObject(metricStr, PrometheusMetricBo.class);
    } catch (Exception e) {
        log.error("getQuery url:{} paramMap:{} error:{}", url, paramMap, e.getMessage(), e);
        return null;
    }
}
### 类导入的包
cn.hutool.http.HttpUtil
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.k8s.domain.bo.PrometheusMetricBo
org.apache.commons.lang3.StringUtils
java.util.Map
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.util下的类PrometheusUtil中有一个名为getQueryRangeParamMap的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Map<String, Object> getQueryRangeParamMap(String param, Long startTime, Long endTime, Integer step) {
    Map<String, Object> paramMap = new HashedMap<>();
    if (StringUtils.isEmpty(param)) {
        return paramMap;
    }
    paramMap.put("query", param);
    if (startTime != null) {
        paramMap.put("start", startTime);
    }
    if (endTime != null) {
        paramMap.put("end", endTime);
    }
    if (step != null) {
        paramMap.put("step", step);
    }
    return paramMap;
}
### 类导入的包
org.apache.commons.collections4.map.HashedMap
org.apache.commons.lang3.StringUtils
java.util.Map
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.util下的类PrometheusUtil中有一个名为getQueryParamMap的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Map<String, Object> getQueryParamMap(String param, Long time) {
    Map<String, Object> paramMap = new HashedMap<>();
    if (StringUtils.isEmpty(param)) {
        return paramMap;
    }
    paramMap.put("query", param);
    if (time != null) {
        paramMap.put("time", time);
    }
    return paramMap;
}
### 类导入的包
org.apache.commons.collections4.map.HashedMap
org.apache.commons.lang3.StringUtils
java.util.Map
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.k8s.util下的类PrometheusUtil中有一个名为getQueryGpuParamMap的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Map<String, Object> getQueryGpuParamMap(String param, String nodeName, String gpuName, Long time) {
    Map<String, Object> paramMap = new HashedMap<>();
    if (StringUtils.isEmpty(param) || StringUtils.isEmpty(nodeName)) {
        return paramMap;
    }
    paramMap.put("query", param.replace("node-name", nodeName).replace("gpu-name", gpuName));
    if (time != null) {
        paramMap.put("time", time);
    }
    return paramMap;
}
### 类导入的包
org.apache.commons.collections4.map.HashedMap
org.apache.commons.lang3.StringUtils
java.util.Map
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.imgcls下的类Imgcls中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例 0
    StringBuilder sb = new StringBuilder();
    sb.append(index).append("\r\n");
    return sb.toString();
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.imgcls下的类Imgcls中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    //        示例
    //        {
    //            "label_index": "0"
    //        }
    JSONObject label = new JSONObject();
    label.put("label_index", index);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.imgcls下的类Imgcls中有一个名为generateLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Object generateLabel(String type) {
    if (Objects.equals(type, "service_train")) {
        //          示例
        //          0
        return labelIndex;
    }
    if (Objects.equals(type, "intelligent_annotation")) {
        //          示例
        //          0
        return labelIndex;
    } else {
        return null;
    }
}
### 类导入的包
java.util.Objects
### 类级别的变量
private String labelIndex;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.imgcls下的类Imgcls中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String json = "{}";
    Imgcls model = JSONObject.parseObject(json, Imgcls.class);
    model.transform("0");
    System.out.println(model.generateTxt("0"));
    System.out.println(JSON.toJSONString(model.generateJson("0")));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.object下的类Rectangle中有一个名为transform的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void transform(String annotationFormat) {
    //转换成coco格式
    if (Objects.equals("1", annotationFormat) && coordinate1 == null) {
    }
    //转换成yolo格式
    if (Objects.equals("2", annotationFormat) && coordinate1 == null) {
    }
    //转换成pascal格式
    if (Objects.equals("3", annotationFormat) && coordinate1 == null) {
    }
}
### 类导入的包
java.util.Objects
### 类级别的变量
/**
 * coco_x_min,yolo_x_center,pascal_x_min
 */
private BigDecimal coordinate1;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.object下的类Rectangle中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例 0 622.000000 476.000000 722.000000 621.000000
    StringBuilder sb = new StringBuilder();
    sb.append(index).append(" ").append(coordinate1).append(" ").append(coordinate2).append(" ").append(coordinate3).append(" ").append(coordinate4).append("\r\n");
    return sb.toString();
}
### 类导入的包

### 类级别的变量
/**
 * coco_x_min,yolo_x_center,pascal_x_min
 */
private BigDecimal coordinate1;
/**
 * coco_y_min,yolo_y_center,pascal_y_min
 */
private BigDecimal coordinate2;
/**
 * coco_width,yolo_width,pascal_x_max
 */
private BigDecimal coordinate3;
/**
 * coco_height,yolo_height,pascal_y_max
 */
private BigDecimal coordinate4;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.object下的类Rectangle中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    //        示例
    //        {
    //            "label_index": "0",
    //            "label_h": 145,
    //            "label_w": 100,
    //            "label_y1": 475,
    //            "label_x1": 622
    //        }
    JSONObject label = new JSONObject();
    label.put("label_x1", labelX1);
    label.put("label_y1", labelY1);
    label.put("label_w", labelW);
    label.put("label_h", labelH);
    label.put("label_index", index);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
/**
 * X1坐标
 */
private Long labelX1;
/**
 * y1坐标
 */
private Long labelY1;
/**
 * 宽度
 */
private Long labelW;
/**
 * 高度
 */
private Long labelH;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.object下的类Rectangle中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String json = "{\"labelX1\":156,\"labelY1\":95,\"labelW\":61,\"labelH\":58,\"coordinate1\":156,\"coordinate2\":95,\"coordinate3\":218,\"coordinate4\":153}";
    Rectangle model = JSONObject.parseObject(json, Rectangle.class);
    model.transform("1");
    System.out.println(JSON.toJSONString(model));
    System.out.println(model.generateTxt("0"));
    System.out.println(JSON.toJSONString(model.generateJson("0")));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
/**
 * X1坐标
 */
private Long labelX1;
/**
 * y1坐标
 */
private Long labelY1;
/**
 * 宽度
 */
private Long labelW;
/**
 * 高度
 */
private Long labelH;
/**
 * coco_x_min,yolo_x_center,pascal_x_min
 */
private BigDecimal coordinate1;
/**
 * coco_y_min,yolo_y_center,pascal_y_min
 */
private BigDecimal coordinate2;
/**
 * coco_width,yolo_width,pascal_x_max
 */
private BigDecimal coordinate3;
/**
 * coco_height,yolo_height,pascal_y_max
 */
private BigDecimal coordinate4;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.segment下的类Instance中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例：0 107 494 182 485 206 562 125 584 \r\n
    StringBuilder sb = new StringBuilder();
    sb.append(index).append(" ");
    points.forEach(object -> {
        JSONObject point = JSONObject.parseObject(object.toString());
        sb.append(point.get("x")).append(" ").append(point.get("y")).append(" ");
    });
    sb.append("\r\n");
    return sb.toString();
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
private JSONArray points;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.segment下的类Instance中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    //        示例
    JSONObject label = new JSONObject();
    label.put("label_index", index);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.segment下的类Instance中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String json = "{\"points\":[{\"x\":107,\"y\":494},{\"x\":182,\"y\":485},{\"x\":206,\"y\":562},{\"x\":125,\"y\":584}]}";
    Instance model = JSONObject.parseObject(json, Instance.class);
    model.transform("0");
    System.out.println(model.generateTxt("0"));
    System.out.println(JSON.toJSONString(model.generateJson("0")));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
private JSONArray points;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.segment下的类Semantic中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例：0 107 494 182 485 206 562 125 584 \r\n
    StringBuilder sb = new StringBuilder();
    sb.append(index).append(" ");
    points.forEach(object -> {
        JSONObject point = JSONObject.parseObject(object.toString());
        sb.append(point.get("x")).append(" ").append(point.get("y")).append(" ");
    });
    sb.append("\r\n");
    return sb.toString();
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
private JSONArray points;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.segment下的类Semantic中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    //        示例
    JSONObject label = new JSONObject();
    label.put("label_index", index);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.pic.segment下的类Semantic中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String json = "{\"points\":[{\"x\":107,\"y\":494},{\"x\":182,\"y\":485},{\"x\":206,\"y\":562},{\"x\":125,\"y\":584}]}";
    Semantic model = JSONObject.parseObject(json, Semantic.class);
    model.transform("0");
    System.out.println(model.generateTxt("0"));
    System.out.println(JSON.toJSONString(model.generateJson("0")));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
private JSONArray points;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtcls下的类Txtcls中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例 0
    StringBuilder sb = new StringBuilder();
    sb.append(index).append("\r\n");
    return sb.toString();
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtcls下的类Txtcls中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    //        示例
    //        {
    //            "index": "0"
    //        }
    JSONObject label = new JSONObject();
    label.put("index", index);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtcls下的类Txtcls中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String json = "{}";
    Txtcls model = JSONObject.parseObject(json, Txtcls.class);
    model.transform("0");
    System.out.println(model.generateTxt("0"));
    System.out.println(JSON.toJSONString(model.generateJson("0")));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtclsm下的类Txtclsm中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例 0
    StringBuilder sb = new StringBuilder();
    sb.append(index).append("\r\n");
    return sb.toString();
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtclsm下的类Txtclsm中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    //        示例
    //        {
    //            "index": "0"
    //        }
    JSONObject label = new JSONObject();
    label.put("index", index);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtclsm下的类Txtclsm中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String json = "{}";
    Txtclsm model = JSONObject.parseObject(json, Txtclsm.class);
    model.transform("0");
    System.out.println(model.generateTxt("0"));
    System.out.println(JSON.toJSONString(model.generateJson("0")));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtentity下的类TxtEntity中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例 0 28 51
    StringBuilder sb = new StringBuilder();
    sb.append(index).append(" ").append(start).append(" ").append(end).append("\r\n");
    return sb.toString();
}
### 类导入的包

### 类级别的变量
private long start;
private long end;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtentity下的类TxtEntity中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    //        示例
    //        {
    //            "index": "0",
    //            "start": 28,
    //            "end": 51
    //         }
    JSONObject label = new JSONObject();
    label.put("start", start);
    label.put("end", end);
    label.put("index", index);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
private long start;
private long end;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtentity下的类TxtEntity中有一个名为generateLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Object generateLabel(String type) {
    if (Objects.equals(type, "service_train")) {
        //        示例
        //        {
        //            "entity_group": "english",
        //            "start": 740,
        //            "end": 742
        //        }
        JSONObject label = new JSONObject();
        label.put("start", start);
        label.put("end", end);
        label.put("entity_group", labelName);
        return label;
    } else if (Objects.equals(type, "intelligent_annotation")) {
        //        示例
        //        {
        //            "entity_group": "1",
        //            "start": 740,
        //            "end": 742
        //        }
        JSONObject label = new JSONObject();
        label.put("start", start);
        label.put("end", end);
        label.put("entity_group", labelIndex);
        return label;
    } else {
        return null;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
java.util.Objects
### 类级别的变量
private long start;
private long end;
private String labelName;
private String labelIndex;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.txt.txtentity下的类TxtEntity中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String json = "{\"start\":28,\"end\":51}";
    TxtEntity model = JSONObject.parseObject(json, TxtEntity.class);
    model.transform("0");
    System.out.println(model.generateTxt("0"));
    System.out.println(JSON.toJSONString(model.generateJson("0")));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
private long start;
private long end;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.video.videotracking下的类VideoTracking中有一个名为generateTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String generateTxt(String index) {
    //示例 1,2,1338.0,418.0,167.0,379.0,1,1,1.0
    //gt格式 videoFrame trackId originalGapLeft originalGapTop originalGapWidth originalGapHeight ConfidenceScore fileLabelId Visibility
    StringBuilder sb = new StringBuilder();
    for (Track trackFrame : track) {
        sb.append(trackFrame.getVideoFrame()).append(" ").append(trackId).append(" ").append(trackFrame.getOriginalGapLeft()).append(" ").append(trackFrame.getOriginalGapTop()).append(" ").append(trackFrame.getOriginalWidth()).append(" ").append(trackFrame.getOriginalHeight()).append(" ").append(1).append(" ").append(datalabelIndex).append(" ").append(1.0).append("\r\n");
    }
    return sb.toString();
}
### 类导入的包

### 类级别的变量
private Long datalabelIndex;
private Long trackId;
private Long end;
private List<Track> track;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.model.video.videotracking下的类VideoTracking中有一个名为generateJson的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public JSONObject generateJson(String index) {
    JSONObject label = new JSONObject();
    label.put("fileLabelId", datalabelIndex);
    label.put("start", start);
    label.put("end", end);
    label.put("track", track);
    return label;
}
### 类导入的包
com.alibaba.fastjson.JSONObject
### 类级别的变量
private Long datalabelIndex;
private Long start;
private Long end;
private List<Track> track;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DifyServiceImpl中有一个名为subscriptionInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    }
public JSONObject subscriptionInfo(String difyTenantId) throws IOException {
    // 获取dify工作空间配额信息
    GdaiDifyProject gdaiDifyProject = gdaiDifyProjectService.getDifyProject(difyTenantId);
    /*
{
    "enabled": true,
    "subscription": {
        "plan": "enterprise",
        "interval": "yearly"
    },
    "members": {
        "size": 5,
        "limit": 10
    },
    "apps": {
        "size": 3,
        "limit": 5
    },
    "vector_space": {
        "size": 999,
        "limit": 2000
    },
    "documents_upload_quota": {
        "size": 522,
        "limit": 1000
    },
    "annotation_quota_limit": {
        "size": 200,
        "limit": 500
    }
}
 */
    // 获取dify工作空间用量信息
    JSONObject body = new JSONObject();
    body.put("tenantId", difyTenantId);
    String difyResult = DifyUtils.requestDify("/console/api/gdai/subscription/info", body);
    JSONObject difyResultJson = JSON.parseObject(difyResult).getJSONObject("data");
    JSONObject result = new JSONObject();
    result.put("enabled", true);
    result.put("subscription", JSONObject.parseObject("{ \"plan\": \"enterprise\", \"interval\": \"yearly\" }"));
    JSONObject members = new JSONObject();
    JSONObject apps = new JSONObject();
    JSONObject vectorSpace = new JSONObject();
    JSONObject documentsUploadQuota = new JSONObject();
    JSONObject annotationQuotaLimit = new JSONObject();
    if (gdaiDifyProject == null) {
        members = createSizeLimitObject(1, 1);
        apps = createSizeLimitObject(1, 1);
        vectorSpace = createSizeLimitObject(1, 1);
        documentsUploadQuota = createSizeLimitObject(1, 1);
        annotationQuotaLimit = createSizeLimitObject(1, 1);
    } else {
        members = createSizeLimitObject(difyResultJson.getLong("members_size"), gdaiDifyProject.getMembers());
        apps = createSizeLimitObject(difyResultJson.getLong("apps_size"), gdaiDifyProject.getApps());
        vectorSpace = createSizeLimitObject(difyResultJson.getLong("vector_space_size") / 1024 / 1024, gdaiDifyProject.getVectorSpace());
        documentsUploadQuota = createSizeLimitObject(difyResultJson.getLong("documents_upload_quota_size"), gdaiDifyProject.getDocumentsUploadQuota());
        annotationQuotaLimit = createSizeLimitObject(difyResultJson.getLong("annotation_quota_limit_size"), gdaiDifyProject.getAnnotationQuotaLimit());
    }
    result.put("members", members);
    result.put("apps", apps);
    result.put("vector_space", vectorSpace);
    result.put("documents_upload_quota", documentsUploadQuota);
    result.put("annotation_quota_limit", annotationQuotaLimit);
    result.put("docs_processing", "standard");
    result.put("can_replace_logo", true);
    result.put("model_load_balancing_enabled", true);
    return result;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiDifyProject
com.eshore.gdai.trainingcenter.util.DifyUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDifyProjectService gdaiDifyProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DifyServiceImpl中有一个名为createSizeLimitObject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private JSONObject createSizeLimitObject(long size, long limit) {
    JSONObject obj = new JSONObject();
    obj.put("size", size);
    obj.put("limit", limit);
    return obj;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DifyServiceImpl中有一个名为syncTenantMember的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 同步工作空间下租户成员
     *
     * @param gdaiProject
     * @return
     * @throws IOException
     */
public RestResult syncTenantMember(GdaiProjectVo gdaiProject) throws IOException {
    log.info("GdaiProjectServiceImpl.syncTenantMember params: [{}]", JSON.toJSONString(gdaiProject));
    try {
        if (gdaiProject.getProjectId() != null) {
            GdaiProject project = gdaiProjectService.selectById(gdaiProject.getProjectId());
            GdaiDifyProject difyProject = gdaiDifyProjectService.getDifyProjectByProjectId(project.getProjectId());
            if (project == null) {
                return RestResult.genFailResult("项目不存在");
            }
            if (difyProject != null) {
                syncTenantMemberByProject(project);
                updateDifyTenantId(difyProject);
            }
        } else if (gdaiProject.getGroupId() != null) {
            List<GdaiProject> gdaiProjects = gdaiProjectService.selectList(new EntityWrapper<GdaiProject>().eq("group_id", gdaiProject.getGroupId()));
            for (GdaiProject project : gdaiProjects) {
                GdaiDifyProject difyProject = gdaiDifyProjectService.getDifyProjectByProjectId(project.getProjectId());
                if (difyProject != null) {
                    syncTenantMemberByProject(project);
                    updateDifyTenantId(difyProject);
                }
            }
        } else {
            return RestResult.genFailResult("项目ID或分组ID不能为空");
        }
        return RestResult.genSuccessResult("同步成功");
    } catch (Exception e) {
        log.error("查询项目信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDifyProject
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.service.GdaiProjectService
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private GdaiDifyProjectService gdaiDifyProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DifyServiceImpl中有一个名为syncTenantMemberByProject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void syncTenantMemberByProject(GdaiProject project) throws IOException {
    // 获取AI智算连接平台项目组用户
    List<User> groupUsers = FeignServiceHelper.getGroupUsers(userClient, project.getGroupId());
    List<JSONObject> gdaiUsers = new ArrayList<>();
    for (User groupUser : groupUsers) {
        if (StringUtils.isNotEmpty(groupUser.getEmail())) {
            JSONObject user = new JSONObject();
            user.put("email", groupUser.getEmail());
            user.put("username", groupUser.getUsername());
            // 判断用户角色
            boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(groupUser);
            boolean operAdminRole = SessionUtils.isOperAdminRole(groupUser);
            boolean superAdminRole = SessionUtils.isSuperAdminRole(groupUser);
            user.put("role", (aiGroupAdminRole || operAdminRole || superAdminRole) ? "admin" : "editor");
            gdaiUsers.add(user);
        }
    }
    log.info("AI智算连接平台的用户: {}", JSON.toJSONString(gdaiUsers));
    // 提取需要同步的用户的邮箱
    Set<String> userEmails = gdaiUsers.stream().map(user -> user.getString("email")).collect(Collectors.toSet());
    log.info("AI智算连接平台的用户邮箱: {}", userEmails);
    // 获取dify工作空间现有用户
    JSONObject difyBody = new JSONObject();
    difyBody.put("tenantName", project.getProjectName());
    String result = DifyUtils.requestDify("/console/api/list-members", difyBody);
    JSONObject difyResult = JSON.parseObject(result);
    List<JSONObject> difyUsers = new ArrayList<>();
    if (Objects.equals(difyResult.getString("code"), "200")) {
        difyUsers = difyResult.getJSONArray("data").toJavaList(JSONObject.class);
    }
    log.info("dify工作空间的用户: {}", JSON.toJSONString(difyUsers));
    // 提取现有用户的邮箱
    Set<String> difyUserEmails = difyUsers.stream().map(user -> user.getString("email")).collect(Collectors.toSet());
    log.info("dify工作空间的用户邮箱: {}", difyUserEmails);
    // 批量添加新用户
    List<JSONObject> usersToAdd = gdaiUsers.stream().filter(user -> !difyUserEmails.contains(user.getString("email"))).collect(Collectors.toList());
    if (!usersToAdd.isEmpty()) {
        log.info("需要添加的用户: {}", JSON.toJSONString(usersToAdd));
        for (JSONObject userToAdd : usersToAdd) {
            JSONObject addUserBody = new JSONObject();
            addUserBody.put("tenantName", project.getProjectName());
            addUserBody.put("name", userToAdd.getString("username"));
            addUserBody.put("email", userToAdd.getString("email"));
            addUserBody.put("role", userToAdd.getString("role"));
            String addUserBodyResult = DifyUtils.requestDify("/console/api/create-tenant-member", addUserBody);
            JSONObject addUserResult = JSON.parseObject(addUserBodyResult);
            if (!Objects.equals(addUserResult.getString("code"), "200")) {
                log.error("批量添加用户到工作空间失败，users:{}", JSON.toJSONString(usersToAdd));
            } else {
                log.info("批量添加用户到工作空间成功，users:{}", JSON.toJSONString(usersToAdd));
            }
        }
    }
    // 批量移除不再需要的用户
    List<JSONObject> usersToRemove = difyUsers.stream().filter(user -> !userEmails.contains(user.getString("email"))).collect(Collectors.toList());
    if (!usersToRemove.isEmpty()) {
        log.info("需要移除的用户: {}", JSON.toJSONString(usersToRemove));
        for (JSONObject userToRemove : usersToRemove) {
            JSONObject removeUserBody = new JSONObject();
            removeUserBody.put("email", userToRemove.getString("email"));
            removeUserBody.put("tenantName", project.getProjectName());
            String removeUserBodyResult = DifyUtils.requestDify("/console/api/cancel-tenant-member", removeUserBody);
            JSONObject removeUserResult = JSON.parseObject(removeUserBodyResult);
            if (!Objects.equals(removeUserResult.getString("code"), "200")) {
                log.error("批量从工作空间移除用户失败，users:{}", JSON.toJSONString(usersToRemove));
            } else {
                log.info("批量从工作空间移除用户成功，users:{}", JSON.toJSONString(usersToRemove));
            }
        }
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.util.DifyUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
java.util.Objects
java.util.Set
java.util.stream.Collectors
### 类级别的变量
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DifyServiceImpl中有一个名为updateDifyTenantId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private void updateDifyTenantId(GdaiDifyProject gdaiDifyProject) throws IOException {
    if (gdaiDifyProject != null && StringUtils.isEmpty(gdaiDifyProject.getDifyTenantId())) {
        JSONObject body = new JSONObject();
        body.put("tenantName", gdaiDifyProject.getProjectName());
        String difyResult = DifyUtils.requestDify("/console/api/query-tenant", body);
        JSONObject result = JSON.parseObject(difyResult);
        if (Objects.equals(result.getString("code"), "200")) {
            JSONObject data = result.getJSONObject("data");
            gdaiDifyProject.setDifyTenantId(data.getString("tenantId"));
            gdaiDifyProjectService.updateById(gdaiDifyProject);
        }
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.DifyUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Objects
### 类级别的变量
@Resource
private GdaiDifyProjectService gdaiDifyProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为printFilesAndDirectories的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<DirOrFileInfoVo> printFilesAndDirectories(JSONObject body) {
    log.info("DirOrFileInfoServiceImpl.printFilesAndDirectories params: [{}]", JSON.toJSONString(body));
    String path = body.getString("path");
    if (path != null) {
        List<DirOrFileInfoVo> fileInfos = printFilesAndDirectories(path);
        return fileInfos;
    }
    return null;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.service.DirOrFileInfoService
com.eshore.gdai.trainingcenter.vo.DirOrFileInfoVo
org.springframework.stereotype.Service
java.io.File
java.nio.file.Files
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为performOperation的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Boolean performOperation(JSONObject body) {
    log.info("DirOrFileInfoServiceImpl.performOperation params: [{}]", JSON.toJSONString(body));
    String operationType = body.getString("operationType");
    String sourcePath = body.getString("sourcePath");
    Boolean bo;
    if (operationType.equals("MODIFY")) {
        String destinationPath = body.getString("destinationPath");
        bo = performOperation(operationType, sourcePath, destinationPath);
    } else {
        bo = performOperation(operationType, sourcePath);
    }
    return bo;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.service.DirOrFileInfoService
org.springframework.stereotype.Service
java.io.File
java.nio.file.Path
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为printFilesAndDirectories的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 打印指定路径下的目录和文件，先展示文件夹，再展示文件，并显示修改时间、类型和大小
     *
     * @param path 要扫描的目录路径
     */
public static List<DirOrFileInfoVo> printFilesAndDirectories(String path) {
    List<DirOrFileInfoVo> fileInfos = null;
    File directory = new File(path);
    // 检查路径是否存在以及是否为目录
    if (directory.exists() && directory.isDirectory()) {
        // 调用方法来打印一级目录和文件
        fileInfos = printFilesAndDirectories(directory);
    } else {
        log.info("给定的路径不是一个有效的目录：" + path);
    }
    return fileInfos;
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.DirOrFileInfoVo
java.io.File
java.nio.file.Files
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为printFilesAndDirectories的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 打印目录及其一级子目录和文件，先展示文件夹，再展示文件，并显示修改时间、类型和大小
     *
     * @param dir 当前要扫描的目录
     */
private static List<DirOrFileInfoVo> printFilesAndDirectories(File dir) {
    List<DirOrFileInfoVo> dirs = new ArrayList<>();
    List<DirOrFileInfoVo> files = new ArrayList<>();
    // 获取目录下的所有文件和文件夹
    File[] filesAndDirs = dir.listFiles();
    if (filesAndDirs != null) {
        for (File fileOrDir : filesAndDirs) {
            String type = fileOrDir.isDirectory() ? "Dir" : "File";
            String modifiedTime = dateFormat.format(fileOrDir.lastModified());
            String size = "";
            if (!"Dir".equals(type)) {
                long fileSizeBytes = fileOrDir.length();
                long fileSizeKB = fileSizeBytes / 1024;
                size = fileSizeKB + " KB";
            }
            DirOrFileInfoVo fileInfo = new DirOrFileInfoVo(type, fileOrDir.getName(), modifiedTime, size);
            if (type.equals("Dir")) {
                dirs.add(fileInfo);
            } else {
                files.add(fileInfo);
            }
        }
    }
    dirs.addAll(files);
    return dirs;
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.DirOrFileInfoVo
java.io.File
java.nio.file.Files
java.util.ArrayList
java.util.List
### 类级别的变量
/**
 * 定义日期格式
 */
private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为performOperation的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
// 封装的方法，根据操作类型调用不同的方法
public static Boolean performOperation(String operationType, String... args) {
    OperationType type;
    try {
        type = OperationType.valueOf(operationType.toUpperCase());
    } catch (IllegalArgumentException e) {
        log.info("无效的操作类型: " + operationType);
        return false;
    }
    switch(type) {
        case CREATE:
            if (args.length == 1) {
                createFolder(args[0]);
                return true;
            } else {
                log.info("创建操作需要一个路径参数");
                return false;
            }
        case MODIFY:
            if (args.length == 2) {
                modify(args[0], args[1]);
                return true;
            } else {
                log.info("修改操作需要源路径和目标路径两个参数");
                return false;
            }
        case DELETE:
            if (args.length == 1) {
                delete(args[0]);
                return true;
            } else {
                log.info("删除操作需要一个路径参数");
                return false;
            }
        default:
            log.info("未知的操作类型");
    }
    return false;
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为createFolder的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 创建文件夹
     *
     * @param path
     */
private static void createFolder(String path) {
    File folder = new File(path);
    if (!folder.exists()) {
        folder.mkdirs();
        log.info("文件夹创建成功: " + path);
    } else {
        log.info("文件夹已存在: " + path);
    }
}
### 类导入的包
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为modify的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 修改（重命名/移动）文件或文件夹
     *
     * @param sourcePath
     * @param destinationPath
     */
private static void modify(String sourcePath, String destinationPath) {
    Path source = Paths.get(sourcePath);
    Path destination = Paths.get(destinationPath);
    try {
        Files.move(source, destination, StandardCopyOption.REPLACE_EXISTING);
        log.info("重命名/移动成功: " + sourcePath + " -> " + destinationPath);
    } catch (Exception e) {
        e.printStackTrace();
        log.info("重命名/移动失败");
    }
}
### 类导入的包
java.io.File
java.nio.file.Files
java.nio.file.Path
java.nio.file.Paths
java.nio.file.StandardCopyOption
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类DirOrFileInfoServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除文件或文件夹（递归删除文件夹）
     *
     * @param path
     */
private static void delete(String path) {
    Path itemPath = Paths.get(path);
    File item = itemPath.toFile();
    if (item.exists()) {
        if (item.isDirectory()) {
            File[] files = item.listFiles();
            if (files != null) {
                for (File file : files) {
                    // 递归调用
                    delete(file.getAbsolutePath());
                }
            }
        }
        if (!item.delete()) {
            log.info("删除失败: " + path);
        } else {
            log.info(item.isDirectory() ? "文件夹删除成功" : "文件删除成功");
        }
    } else {
        log.info(path + " 不存在");
    }
}
### 类导入的包
java.io.File
java.nio.file.Files
java.nio.file.Path
java.nio.file.Paths
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为checkFileMd5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> checkFileMd5(String md5, String fileName, String rootPath) {
    log.info("GdaiAlgorithmManageServiceImpl.checkFileMd5 params: [{}],[{}]", fileName, rootPath);
    try {
        Result result = LocalUpload.checkFileMd5(md5, fileName, rootPath + GdaiConstant.BREAK_POINT_CONF_PATH, rootPath + GdaiConstant.BREAK_POINT_PATH);
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("MD5检查异常", e);
    }
    return RestResult.genFailResult("MD5检查异常");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为breakpointUpload的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> breakpointUpload(GdaiAlgorithmManageVo gdaiAlgorithmManageVo, HttpServletRequest request) {
    log.info("GdaiAlgorithmManageServiceImpl.breakpointUpload params: [{}],[{}],[{}],[{}],[{}]", gdaiAlgorithmManageVo.getId(), gdaiAlgorithmManageVo.getChunks(), gdaiAlgorithmManageVo.getChunk(), gdaiAlgorithmManageVo.getSize(), gdaiAlgorithmManageVo.getName());
    try {
        //获取断点续传参数
        String id = gdaiAlgorithmManageVo.getId();
        int chunks = gdaiAlgorithmManageVo.getChunks();
        int chunk = gdaiAlgorithmManageVo.getChunk();
        long size = gdaiAlgorithmManageVo.getSize();
        String name = gdaiAlgorithmManageVo.getName();
        MultipartFile file = gdaiAlgorithmManageVo.getFile();
        String md5 = gdaiAlgorithmManageVo.getMd5();
        //获取上传根目录
        String rootPath = gdaiAlgorithmManageVo.getRootPath();
        //拼装上传压缩包目录
        String filePath = rootPath + GdaiConstant.BREAK_POINT_PATH;
        String confFilePath = rootPath + GdaiConstant.BREAK_POINT_CONF_PATH;
        // 这里的 chunkSize(分片大小) 要与前端传过来的大小一致
        Result result = LocalUpload.fragmentFileUploader(new UploadFileParam(id, chunks, chunk, size, name, file, md5), confFilePath, filePath, 5242880L, request);
        result.setData(filePath);
        String code = result.getCode();
        //状态码为201时表示文件上传完毕，此时对压缩包进行校验
        if ("201".equals(code)) {
            //对压缩包进行合法性检查
            String srcZipPath = filePath + "/" + name;
            //添加不允许的扩展名
            String[] fileTypesArray = disallowedFileType.split(",");
            // 转换字符串数组为List
            List<String> disallowedExtensions = Arrays.stream(fileTypesArray).map(String::trim).collect(Collectors.toList());
            boolean isValid = FileUtil.validateZipFileContainsDisallowedFileTypes(srcZipPath, disallowedExtensions);
            if (!isValid) {
                //校验不通过删除压缩包
                if (StringUtils.isNotBlank(rootPath)) {
                    String filePathTemp = filePath + "/" + name;
                    String confFilePathTemp = confFilePath + "/" + name + ".conf";
                    if (StringUtils.isNotBlank(filePathTemp)) {
                        File files = FileUtils.getFile(filePathTemp);
                        if (files.exists()) {
                            FileUtil.deleteFile(files);
                        }
                    }
                    if (StringUtils.isNotBlank(confFilePathTemp)) {
                        File confFile = FileUtils.getFile(confFilePathTemp);
                        if (confFile.exists()) {
                            FileUtil.deleteFile(confFile);
                        }
                    }
                }
                return RestResult.genFailResult("压缩包为空或者压缩包中包含不允许的文件类型,请删除后重新上传");
            }
        }
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("算法压缩包上传异常", e);
    }
    return RestResult.genFailResult("算法压缩包上传失败");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
com.eshore.gdai.trainingcenter.vo.UploadFileParam
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.Arrays
java.util.List
java.util.stream.Collectors
### 类级别的变量
@Autowired
private HttpServletRequest request;
/**
 * 不允许上传的文件类型
 */
@Value("${upload.disallowedFileType}")
private String disallowedFileType;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为deleteBreakpointFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteBreakpointFile(GdaiAlgorithmManageVo gdaiAlgorithmManageVo) {
    log.info("GdaiAlgorithmManageServiceImpl.deleteBreakpointFile params: [{}]" + JSON.toJSONString(gdaiAlgorithmManageVo));
    String fileName = gdaiAlgorithmManageVo.getName();
    String rootPath = gdaiAlgorithmManageVo.getRootPath();
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("文件名称不能为空");
    }
    if (StringUtils.isBlank(rootPath)) {
        return RestResult.genFailResult("算法存放路径不能为空");
    }
    try {
        //拼装文件完整路径
        String filePath = rootPath + GdaiConstant.BREAK_POINT_PATH + "/" + fileName;
        String confFilePath = rootPath + GdaiConstant.BREAK_POINT_CONF_PATH + "/" + fileName + ".conf";
        if (StringUtils.isNotBlank(filePath)) {
            File file = FileUtils.getFile(filePath);
            if (file.exists()) {
                FileUtil.deleteFile(file);
            }
        }
        if (StringUtils.isNotBlank(confFilePath)) {
            File confFile = FileUtils.getFile(confFilePath);
            if (confFile.exists()) {
                FileUtil.deleteFile(confFile);
            }
        }
    } catch (Exception e) {
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiAlgorithmManage gdaiAlgorithmManage) {
    log.info("GdaiAlgorithmManageServiceImpl.add params: [{}]", JSON.toJSONString(gdaiAlgorithmManage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    String algorithmName = gdaiAlgorithmManage.getAlgorithmName();
    Long projectId = gdaiAlgorithmManage.getProjectId();
    //        Long imageId = gdaiAlgorithmManage.getImageId();
    String shareFlag = gdaiAlgorithmManage.getShareFlag();
    if (StringUtils.isBlank(algorithmName)) {
        return RestResult.genFailResult("算法名称不能为空");
    }
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //        if (imageId == null) {
    //            return RestResult.genFailResult("机器学习框架镜像ID不能为空");
    //        }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    try {
        //查询同项目下是否存在同名算法包
        GdaiAlgorithmManage algorithmManage = gdaiAlgorithmManageMapper.selectOne(new GdaiAlgorithmManage(algorithmName, projectId, userId));
        if (algorithmManage != null) {
            return RestResult.genFailResult("该项目下已存在同名算法包");
        }
        //拼装算法包保存路径
        Date curDate = new Date();
        gdaiAlgorithmManage.setCreatorId(userId);
        gdaiAlgorithmManage.setCreateTime(curDate);
        gdaiAlgorithmManage.setModifyTime(curDate);
        gdaiAlgorithmManageMapper.insert(gdaiAlgorithmManage);
        Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
        File directory = DirectoryUtils.createDirectory(projectId.toString(), userId.toString(), GdaiConstant.ALGORITHM1, String.valueOf(algorithmId));
        if (directory == null) {
            throw new TrainginCenterException("算法管理目录创建异常");
        }
        String algorithmSavePath = directory.getAbsolutePath();
        String rootPath = directory.getAbsolutePath();
        gdaiAlgorithmManageMapper.updateById(new GdaiAlgorithmManage(algorithmId, algorithmSavePath, rootPath));
    } catch (Exception e) {
        log.info("新增算法信息异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.DirectoryUtils
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为addAlgorithmManage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiAlgorithmManage addAlgorithmManage(GdaiAlgorithmManage gdaiAlgorithmManage) throws TrainginCenterException {
    log.info("addAlgorithmManage.add params: [{}]", JSON.toJSONString(gdaiAlgorithmManage));
    String algorithmName = gdaiAlgorithmManage.getAlgorithmName();
    Long projectId = gdaiAlgorithmManage.getProjectId();
    Long imageId = gdaiAlgorithmManage.getImageId();
    String shareFlag = gdaiAlgorithmManage.getShareFlag();
    Long userId = gdaiAlgorithmManage.getCreatorId();
    if (StringUtils.isBlank(algorithmName)) {
        throw new TrainginCenterException("算法名称不能为空");
    }
    if (projectId == null) {
        throw new TrainginCenterException("项目ID不能为空");
    }
    //        if (imageId == null) {
    //            throw new TrainginCenterException("机器学习框架镜像ID不能为空");
    //        }
    if (StringUtils.isBlank(shareFlag)) {
        throw new TrainginCenterException("共享标识不能为空");
    }
    //查询同项目下是否存在同名算法包
    GdaiAlgorithmManage algorithmManage = gdaiAlgorithmManageMapper.selectOne(new GdaiAlgorithmManage(algorithmName, projectId, userId));
    if (algorithmManage != null) {
        throw new TrainginCenterException("该项目下已存在同名算法包");
    }
    try {
        Date curDate = new Date();
        gdaiAlgorithmManage.setCreatorId(userId);
        gdaiAlgorithmManage.setCreateTime(curDate);
        gdaiAlgorithmManage.setModifyTime(curDate);
        gdaiAlgorithmManageMapper.insert(gdaiAlgorithmManage);
        //拼装算法包保存路径
        Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
        File directory = DirectoryUtils.createDirectory(projectId.toString(), userId.toString(), GdaiConstant.ALGORITHM1, String.valueOf(algorithmId));
        if (directory == null) {
            throw new TrainginCenterException("算法开发目录创建异常");
        }
        String algorithmSavePath = directory.getAbsolutePath();
        String rootPath = directory.getAbsolutePath();
        gdaiAlgorithmManageMapper.updateById(new GdaiAlgorithmManage(algorithmId, algorithmSavePath, rootPath));
        return gdaiAlgorithmManageMapper.selectById(algorithmId);
    } catch (Exception e) {
        log.info("新增算法信息异常", e);
        throw new TrainginCenterException("新增算法包异常" + e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.util.DirectoryUtils
org.apache.commons.lang3.StringUtils
java.io.File
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiAlgorithmManage gdaiAlgorithmManage) throws TrainginCenterException {
    log.info("GdaiAlgorithmManageServiceImpl.updateShareFlag params: [{}]", JSON.toJSONString(gdaiAlgorithmManage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //        Long userId = user.getId();
    Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
    String shareFlag = gdaiAlgorithmManage.getShareFlag();
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    GdaiAlgorithmManage algorithmManage = checkGdaiAlgorithmManage(user, algorithmId, false);
    //        GdaiAlgorithmManage algorithmManage = gdaiAlgorithmManageMapper.selectById(algorithmId);
    //        if (algorithmManage == null) {
    //            return RestResult.genFailResult("该记录不存在");
    //        }
    //        //修改之前判断当前修改人是否和创建人一致（该条记录的创建者才有修改权限）
    //        Long creatorId = algorithmManage.getCreatorId();
    //        if (!creatorId.equals(userId)) {
    //            return RestResult.genFailResult("非创建者不能修改该状态");
    //        }
    GdaiAlgorithmManage manage = new GdaiAlgorithmManage();
    manage.setAlgorithmId(algorithmId);
    manage.setShareFlag(shareFlag);
    manage.setModifyTime(new Date());
    gdaiAlgorithmManageMapper.updateById(manage);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为updateSavePath的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateSavePath(GdaiAlgorithmManageVo gdaiAlgorithmManageVo) throws TrainginCenterException {
    log.info("GdaiAlgorithmManageServiceImpl.updateSavePath params: [{}]", JSON.toJSONString(gdaiAlgorithmManageVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long algorithmId = gdaiAlgorithmManageVo.getAlgorithmId();
    String algorithmSavePath = gdaiAlgorithmManageVo.getAlgorithmSavePath();
    String fileName = gdaiAlgorithmManageVo.getFileName();
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    if (StringUtils.isBlank(algorithmSavePath)) {
        return RestResult.genFailResult("算法保存路径不能为空");
    }
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("压缩包名称不能为空");
    }
    //修复水平越权问题 TBD
    checkGdaiAlgorithmManage(user, algorithmId, false);
    try {
        String srcZipPath = algorithmSavePath + "/" + fileName;
        //将上传的zip包进行解压
        File zipPath = FileUtils.getFile(srcZipPath);
        List<String> unZipPath = ZipUtil.unZip(zipPath, algorithmSavePath);
        //解压完毕删除zip文件
        if (zipPath != null) {
            if (zipPath.exists()) {
                zipPath.delete();
            }
        }
    } catch (Exception e) {
        log.info("解压算法压缩包异常", e);
        return RestResult.genFailResult("保存异常");
    }
    //解压完毕更新路径
    gdaiAlgorithmManageMapper.updateById(new GdaiAlgorithmManage(algorithmId, algorithmSavePath));
    return RestResult.genSuccessResult("保存成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.List
### 类级别的变量
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为onlineEdit的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult onlineEdit(GdaiAlgorithmManageVo gdaiAlgorithmManageVo) throws TrainginCenterException {
    log.info("GdaiAlgorithmManageServiceImpl.onlineEdit params: [{}]", JSON.toJSONString(gdaiAlgorithmManageVo));
    Long projectId = gdaiAlgorithmManageVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long algorithmId = gdaiAlgorithmManageVo.getAlgorithmId();
    Long devId = gdaiAlgorithmManageVo.getDevId();
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    if (devId == null) {
        return RestResult.genFailResult("模型ID不能为空");
    }
    //修复水平越权问题
    checkGdaiAlgorithmManage(user, algorithmId, true);
    //点击在线编辑，先查看本表记录中是否有devId（devId默认为0），如果devId为0表示还没新增模型开发，此时调接口新增模型开发（传送算法保存路径，替换挂载目录）
    try {
        if (devId == 0) {
            return RestResult.genFailResult("请先配置Notebook是开发环境");
        } else {
            //如果点击在线编辑devId不为空，表示已创建开发容器，此时查询当前容器状态，如果是运行中则直接打开，如果是停止中的则启动容器
            GdaiDevModel gdaiDevModel = gdaiDevModelMapper.selectById(devId);
            if (gdaiDevModel != null) {
                String status = gdaiDevModel.getStatus();
                if ("S0R".equals(status)) {
                    //如果是运行中，则返回url打开
                    if (StringUtils.isNotBlank(gdaiDevModel.getJupyterUrl())) {
                        return RestResult.genSuccessResult(gdaiDevModel);
                    }
                    String jupyterUrl = gdaiDevModelServiceImpl.getJupyterUrlV3(gdaiDevModel);
                    if (StringUtils.isNotBlank(jupyterUrl)) {
                        gdaiDevModel.setJupyterUrl(jupyterUrl);
                        gdaiDevModelMapper.updateById(gdaiDevModel);
                        return RestResult.genSuccessResult(gdaiDevModel);
                    } else {
                        return RestResult.genFailResult("Notebook启动中，请稍后再试！");
                    }
                } else if ("S0T".equals(status)) {
                    //如果是停止状态则重新启动
                    GdaiDevModel devModel = new GdaiDevModel();
                    devModel.setDevId(devId);
                    devModel.setProjectId(projectId);
                    RestResult restResult = gdaiDevModelServiceImpl.startNotebook(devModel);
                    String code = restResult.getCode();
                    if ("200".equals(code)) {
                        return RestResult.genSuccessResult(gdaiDevModel);
                    } else {
                        return RestResult.genFailResult("Notebook启动失败");
                    }
                } else if ("S0C".equals(status)) {
                    return RestResult.genSuccessResult("Notebook启动中，请稍等");
                } else if ("S0TC".equals(status)) {
                    return RestResult.genSuccessResult("Notebook停止中，请稍等");
                } else if ("S0D".equals(status)) {
                    return RestResult.genSuccessResult("Notebook删除中，请稍等");
                } else if ("S0E".equals(status)) {
                    return RestResult.genSuccessResult("Notebook运行异常，可删除Notebook记录重新创建");
                }
            }
        }
    } catch (Exception e) {
        log.info("在线编辑异常：[{}]", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return RestResult.genFailResult("在线编辑失败");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Autowired
private HttpServletRequest request;
@Resource
private GdaiDevModelServiceImpl gdaiDevModelServiceImpl;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiAlgorithmManage gdaiAlgorithmManage) {
    log.info("GdaiAlgorithmManageServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiAlgorithmManage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    try {
        //修复水平越权问题
        GdaiAlgorithmManage algorithmManage = checkGdaiAlgorithmManage(user, algorithmId, false);
        //            GdaiAlgorithmManage algorithmManage = gdaiAlgorithmManageMapper.selectById(algorithmId);
        //            if (algorithmManage == null) {
        //                return RestResult.genFailResult("该算法信息不存在");
        //            }
        //
        //            //判断用户是否是超级管理员,如果是超管则直接删除,如果不是超管,删除之前判断当前用户是否和创建人一致（该条记录的创建者才有删除权限）
        //            Boolean superAdminRole = CommonTools.checkDeletePermission(request, userId, algorithmManage.getCreatorId());
        //            if (!superAdminRole) {
        //                return RestResult.genFailResult("非创建者不能删除该记录");
        //            }
        //根据算法ID查询该算法下是否存在相关的训练记录
        List<GdaiTrainingModel> gdaiTrainingModels = gdaiTrainingModelMapper.selectList(new EntityWrapper<GdaiTrainingModel>().eq("algorithm_id", algorithmId));
        if (gdaiTrainingModels != null && gdaiTrainingModels.size() > 0) {
            return RestResult.genFailResult("该算法下存在训练记录，请先删除该记录");
        }
        //删除对应算法文件
        String rootPath = algorithmManage.getRootPath();
        if (StringUtils.isNotBlank(rootPath)) {
            File file = FileUtils.getFile(rootPath);
            if (file.exists()) {
                FileUtil.deleteFile(file);
            }
        }
        gdaiAlgorithmManageMapper.deleteById(algorithmId);
    } catch (Exception e) {
        log.info("删除算法信息异常：[{}]", e);
        return RestResult.genFailResult("删除算法信息异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.List
### 类级别的变量
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Autowired
private HttpServletRequest request;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为queryAlgorithm的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAlgorithm(GdaiAlgorithmManageVo gdaiAlgorithmManageVo) {
    log.info("GdaiAlgorithmManageServiceImpl.queryAlgorithm params: [{}]", JSON.toJSONString(gdaiAlgorithmManageVo));
    Long projectId = gdaiAlgorithmManageVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String algorithmName = gdaiAlgorithmManageVo.getAlgorithmName();
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员上传的算法包
        UiPage<GdaiAlgorithmManageVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiAlgorithmManageVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiAlgorithmManage> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId);
        // 如果algorithmName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(algorithmName)) {
            wrapper.like("algorithm_name", algorithmName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiAlgorithmManage> gdaiAlgorithmManagePage = gdaiAlgorithmManageService.selectPage(new Page<>(gdaiAlgorithmManageVo.getPageNumber(), gdaiAlgorithmManageVo.getPageCount()), wrapper);
        if (gdaiAlgorithmManagePage != null && gdaiAlgorithmManagePage.getRecords().size() > 0) {
            List<GdaiAlgorithmManage> records = gdaiAlgorithmManagePage.getRecords();
            for (GdaiAlgorithmManage gdaiAlgorithmManage : records) {
                gdaiAlgorithmManageVo = new GdaiAlgorithmManageVo();
                BeanUtils.copyProperties(gdaiAlgorithmManage, gdaiAlgorithmManageVo);
                Long creatorId = gdaiAlgorithmManage.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiAlgorithmManageVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiAlgorithmManageVo);
            }
            uiPage.setTotal(gdaiAlgorithmManagePage.getTotal());
            uiPage.setPageSize(gdaiAlgorithmManagePage.getSize());
            uiPage.setPages(gdaiAlgorithmManagePage.getPages());
            uiPage.setPageNum(gdaiAlgorithmManagePage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    } else {
        UiPage<GdaiAlgorithmManageVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiAlgorithmManageVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiAlgorithmManage> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId).andNew().eq("share_flag", "1").or().eq("creator_id", userId);
        // 如果algorithmName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(algorithmName)) {
            wrapper.like("algorithm_name", algorithmName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiAlgorithmManage> gdaiAlgorithmManagePage = gdaiAlgorithmManageService.selectPage(new Page<>(gdaiAlgorithmManageVo.getPageNumber(), gdaiAlgorithmManageVo.getPageCount()), wrapper);
        if (gdaiAlgorithmManagePage != null && gdaiAlgorithmManagePage.getRecords().size() > 0) {
            List<GdaiAlgorithmManage> records = gdaiAlgorithmManagePage.getRecords();
            for (GdaiAlgorithmManage gdaiAlgorithmManage : records) {
                gdaiAlgorithmManageVo = new GdaiAlgorithmManageVo();
                BeanUtils.copyProperties(gdaiAlgorithmManage, gdaiAlgorithmManageVo);
                Long creatorId = gdaiAlgorithmManage.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiAlgorithmManageVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiAlgorithmManageVo);
            }
            uiPage.setTotal(gdaiAlgorithmManagePage.getTotal());
            uiPage.setPageSize(gdaiAlgorithmManagePage.getSize());
            uiPage.setPages(gdaiAlgorithmManagePage.getPages());
            uiPage.setPageNum(gdaiAlgorithmManagePage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmManageVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiAlgorithmManageService gdaiAlgorithmManageService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为queryAlgorithmGroup的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAlgorithmGroup(GdaiAlgorithmManageVo gdaiAlgorithmManageVo) {
    log.info("GdaiAlgorithmManageServiceImpl.queryAlgorithmGroup params: [{}]", JSON.toJSONString(gdaiAlgorithmManageVo));
    Long projectId = gdaiAlgorithmManageVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String algorithmName = gdaiAlgorithmManageVo.getAlgorithmName();
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员上传的算法包
        UiPage<GdaiAlgorithmManageVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiAlgorithmManageVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiAlgorithmManage> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId);
        // 如果algorithmName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(algorithmName)) {
            wrapper.like("algorithm_name", algorithmName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiAlgorithmManage> gdaiAlgorithmManagePage = gdaiAlgorithmManageService.selectPage(new Page<>(gdaiAlgorithmManageVo.getPageNumber(), gdaiAlgorithmManageVo.getPageCount()), wrapper);
        if (gdaiAlgorithmManagePage != null && gdaiAlgorithmManagePage.getRecords().size() > 0) {
            List<GdaiAlgorithmManage> records = gdaiAlgorithmManagePage.getRecords();
            for (GdaiAlgorithmManage gdaiAlgorithmManage : records) {
                gdaiAlgorithmManageVo = new GdaiAlgorithmManageVo();
                BeanUtils.copyProperties(gdaiAlgorithmManage, gdaiAlgorithmManageVo);
                Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
                Long creatorId = gdaiAlgorithmManage.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiAlgorithmManageVo.setCreatorName(userInfo.getUsername());
                }
                //查询当前自训练组下拥有的版本数
                int versionCount = gdaiAlgorithmManageMapper.queryVersionCount(algorithmId, null);
                gdaiAlgorithmManageVo.setVersionCount(versionCount);
                list.add(gdaiAlgorithmManageVo);
            }
            uiPage.setTotal(gdaiAlgorithmManagePage.getTotal());
            uiPage.setPageSize(gdaiAlgorithmManagePage.getSize());
            uiPage.setPages(gdaiAlgorithmManagePage.getPages());
            uiPage.setPageNum(gdaiAlgorithmManagePage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    } else {
        UiPage<GdaiAlgorithmManageVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiAlgorithmManageVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiAlgorithmManage> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId).andNew().eq("share_flag", "1").or().eq("creator_id", userId);
        // 如果algorithmName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(algorithmName)) {
            wrapper.like("algorithm_name", algorithmName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiAlgorithmManage> gdaiAlgorithmManagePage = gdaiAlgorithmManageService.selectPage(new Page<>(gdaiAlgorithmManageVo.getPageNumber(), gdaiAlgorithmManageVo.getPageCount()), wrapper);
        if (gdaiAlgorithmManagePage != null && gdaiAlgorithmManagePage.getRecords().size() > 0) {
            List<GdaiAlgorithmManage> records = gdaiAlgorithmManagePage.getRecords();
            for (GdaiAlgorithmManage gdaiAlgorithmManage : records) {
                gdaiAlgorithmManageVo = new GdaiAlgorithmManageVo();
                BeanUtils.copyProperties(gdaiAlgorithmManage, gdaiAlgorithmManageVo);
                Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
                Long creatorId = gdaiAlgorithmManage.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiAlgorithmManageVo.setCreatorName(userInfo.getUsername());
                }
                //查询当前自训练组下拥有的版本数
                int versionCount = gdaiAlgorithmManageMapper.queryVersionCount(algorithmId, userId);
                gdaiAlgorithmManageVo.setVersionCount(versionCount);
                list.add(gdaiAlgorithmManageVo);
            }
            uiPage.setTotal(gdaiAlgorithmManagePage.getTotal());
            uiPage.setPageSize(gdaiAlgorithmManagePage.getSize());
            uiPage.setPages(gdaiAlgorithmManagePage.getPages());
            uiPage.setPageNum(gdaiAlgorithmManagePage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmManageVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Resource
private GdaiAlgorithmManageService gdaiAlgorithmManageService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为queryAlgorithmNoPage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAlgorithmNoPage(GdaiAlgorithmManage gdaiAlgorithmManage) {
    log.info("GdaiAlgorithmManageServiceImpl.queryAlgorithmNoPage params: [{}]" + JSON.toJSONString(gdaiAlgorithmManage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    //        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(request);
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    List<String> desc = new ArrayList<>();
    desc.add("modify_time");
    List<GdaiAlgorithmManage> gdaiAlgorithmManages;
    Long projectId = gdaiAlgorithmManage.getProjectId();
    try {
        if (aiGroupAdminRole) {
            gdaiAlgorithmManages = gdaiAlgorithmManageService.selectList(new EntityWrapper<GdaiAlgorithmManage>().eq("project_id", projectId).orderDesc(desc));
        } else {
            gdaiAlgorithmManages = gdaiAlgorithmManageService.selectList(new EntityWrapper<GdaiAlgorithmManage>().eq("project_id", projectId).andNew().eq("share_flag", "1").or().eq("creator_id", userId).orderDesc(desc));
        }
    } catch (Exception e) {
        log.info("查询算法信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiAlgorithmManages);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiAlgorithmManageService gdaiAlgorithmManageService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为queryAlgorithmById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAlgorithmById(GdaiAlgorithmManage gdaiAlgorithmManage) {
    log.info("GdaiAlgorithmManageServiceImpl.queryAlgorithmById params: [{}]" + JSON.toJSONString(gdaiAlgorithmManage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    GdaiAlgorithmManage gdaiAlgorithmManage1;
    try {
        //修复水平越权问题
        gdaiAlgorithmManage1 = checkGdaiAlgorithmManage(user, algorithmId, true);
        //            gdaiAlgorithmManage1 = gdaiAlgorithmManageService.selectById(algorithmId);
    } catch (Exception e) {
        log.info("根据ID查询算法信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiAlgorithmManage1);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiAlgorithmManageService gdaiAlgorithmManageService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为downloadAlgorithm的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadAlgorithm(Long algorithmId, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiAlgorithmManageServiceImpl.downloadAlgorithm params: [{}]", JSON.toJSONString(algorithmId));
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //根据模型ID查询该模型状态，若已完成训练则可以去对应路径下载训练完模型
        //修复水平越权问题
        GdaiAlgorithmManage gdaiAlgorithmManage = checkGdaiAlgorithmManage(user, algorithmId, true);
        //            GdaiAlgorithmManage gdaiAlgorithmManage = gdaiAlgorithmManageService.selectById(algorithmId);
        //            if (gdaiAlgorithmManage == null) {
        //                return RestResult.genFailResult("该算法信息不存在");
        //            }
        //获取算法保存路径
        String algorithmSavePath = gdaiAlgorithmManage.getAlgorithmSavePath();
        if (StringUtils.isBlank(algorithmSavePath)) {
            return RestResult.genFailResult("算法保存路径为空");
        }
        String fileName = "algorithm_" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(algorithmSavePath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmManageService
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmManageService gdaiAlgorithmManageService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmManageServiceImpl中有一个名为checkGdaiAlgorithmManage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//查询 修改 true   删除 false
 GdaiAlgorithmManage checkGdaiAlgorithmManage(User user, Long algorithmId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiAlgorithmManage gdaiAlgorithmManage = gdaiAlgorithmManageMapper.selectById(algorithmId);
    if (gdaiAlgorithmManage == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiAlgorithmManage.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiAlgorithmManage.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiAlgorithmManage.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiAlgorithmManage;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
org.springframework.stereotype.Service
java.util.Set
### 类级别的变量
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Resource
private GdaiProjectService gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为submitOrder的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult submitOrder(GdaiAlgorithmOrder gdaiAlgorithmOrder) {
    log.info("GdaiAlgorithmOrderServiceImpl.submitOrder params: [{}]", JSON.toJSONString(gdaiAlgorithmOrder));
    String orderType = gdaiAlgorithmOrder.getOrderType();
    String orderSource = gdaiAlgorithmOrder.getOrderSource();
    String orderOperation = gdaiAlgorithmOrder.getOrderOperation();
    JSONObject orderContent = gdaiAlgorithmOrder.getOrderContent();
    String orderDeployPool = gdaiAlgorithmOrder.getOrderDeployPool();
    String crmOrderId = gdaiAlgorithmOrder.getCrmOrderId();
    Long creatorId = gdaiAlgorithmOrder.getCreatorId();
    if (StringUtils.isBlank(orderType)) {
        return RestResult.genFailResult("订单类型不能为空");
    }
    if (StringUtils.isBlank(orderSource)) {
        return RestResult.genFailResult("订单来源不能为空");
    }
    if (StringUtils.isBlank(orderOperation)) {
        return RestResult.genFailResult("操作类型不能为空");
    }
    if (orderContent == null) {
        return RestResult.genFailResult("订单内容不能为空");
    }
    if (StringUtils.isBlank(orderDeployPool)) {
        return RestResult.genFailResult("部署资源池不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    if (StringUtils.isBlank(crmOrderId)) {
        return RestResult.genFailResult("CRM订单号不能为空");
    }
    try {
        //参数组装
        JSONObject jsonObject = parameterAssembly(gdaiAlgorithmOrder);
        if (jsonObject == null) {
            return RestResult.genFailResult("参数组装异常");
        } else {
            gdaiAlgorithmOrder.setOrderContent(jsonObject);
        }
        Date date = new Date();
        gdaiAlgorithmOrder.setCreateTime(date);
        gdaiAlgorithmOrder.setModifyTime(date);
        gdaiAlgorithmOrder.setModifierId(creatorId);
        //订单状态：1-待处理，2-处理中，3-处理成功，4-处理失败，5-处理异常
        gdaiAlgorithmOrder.setOrderStatus("1");
        gdaiAlgorithmOrder.setOrderStatusReason("待处理");
        gdaiAlgorithmOrder.setOrderResult(" ");
        gdaiAlgorithmOrderMapper.add(gdaiAlgorithmOrder);
        return RestResult.genSuccessResult("下单成功");
    } catch (Exception e) {
        log.info("下单异常", e);
        return RestResult.genFailResult("下单异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmOrderService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为updateBizId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateBizId(GdaiAlgorithmOrder gdaiAlgorithmOrder) {
    log.info("GdaiAlgorithmOrderServiceImpl.updateBizId params: [{}]", JSON.toJSONString(gdaiAlgorithmOrder));
    String bizId = gdaiAlgorithmOrder.getBizId();
    try {
        if (StringUtils.isBlank(bizId)) {
            return RestResult.genFailResult("业务ID不能为空");
        }
        Long orderId = gdaiAlgorithmOrder.getOrderId();
        if (orderId == null) {
            return RestResult.genFailResult("订单ID不能为空");
        }
        gdaiAlgorithmOrderMapper.updateById(gdaiAlgorithmOrder);
        return RestResult.genSuccessResult("同步业务ID成功");
    } catch (Exception e) {
        log.info("同步业务ID异常:", e);
        return RestResult.genFailResult("同步业务ID异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmOrderService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为updateOrder的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateOrder(GdaiAlgorithmOrder gdaiAlgorithmOrder) {
    log.info("GdaiAlgorithmOrderServiceImpl.updateOrder params: [{}]", JSON.toJSONString(gdaiAlgorithmOrder));
    Long orderId = gdaiAlgorithmOrder.getOrderId();
    if (orderId == null) {
        return RestResult.genFailResult("订单ID不能为空");
    }
    String orderStatus = gdaiAlgorithmOrder.getOrderStatus();
    if (StringUtils.isBlank(orderStatus)) {
        return RestResult.genFailResult("订单状态不能为空");
    }
    String orderStatusReason = gdaiAlgorithmOrder.getOrderStatusReason();
    if (StringUtils.isBlank(orderStatusReason)) {
        return RestResult.genFailResult("订单状态原因不能为空");
    }
    String orderResult = gdaiAlgorithmOrder.getOrderResult();
    try {
        gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, orderStatus, orderStatusReason, orderResult, new Date()));
        return RestResult.genSuccessResult("更新订单信息成功");
    } catch (Exception e) {
        log.info("更新订单信息异常", e);
        return RestResult.genFailResult("更新订单信息异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmOrderService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为receiptOrder的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult receiptOrder(GdaiAlgorithmOrder gdaiAlgorithmOrder) {
    log.info("GdaiAlgorithmOrderServiceImpl.receiptOrder params: [{}]", JSON.toJSONString(gdaiAlgorithmOrder));
    Long orderId = gdaiAlgorithmOrder.getOrderId();
    if (orderId == null) {
        return RestResult.genFailResult("订单ID不能为空");
    }
    String orderReceiptStatus = gdaiAlgorithmOrder.getOrderReceiptStatus();
    if (StringUtils.isBlank(orderReceiptStatus)) {
        return RestResult.genFailResult("订单回单状态不能为空");
    }
    try {
        gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, orderReceiptStatus, new Date()));
        return RestResult.genSuccessResult("回单成功");
    } catch (Exception e) {
        log.info("回单异常", e);
        return RestResult.genFailResult("回单异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmOrderService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为updateAndReceiptOrder的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateAndReceiptOrder(GdaiAlgorithmOrderVo gdaiAlgorithmOrderVo) {
    log.info("GdaiAlgorithmOrderServiceImpl.updateAndReceiptOrder params: [{}]", JSON.toJSONString(gdaiAlgorithmOrderVo));
    Long orderId = gdaiAlgorithmOrderVo.getOrderId();
    if (orderId == null) {
        return RestResult.genFailResult("订单ID不能为空");
    }
    String orderStatus = gdaiAlgorithmOrderVo.getOrderStatus();
    if (StringUtils.isBlank(orderStatus)) {
        return RestResult.genFailResult("订单状态不能为空");
    }
    String orderStatusReason = gdaiAlgorithmOrderVo.getOrderStatusReason();
    if (StringUtils.isBlank(orderStatusReason)) {
        return RestResult.genFailResult("订单状态原因不能为空");
    }
    try {
        //根据订单ID查询crm订单号
        GdaiAlgorithmOrder algorithmOrder = gdaiAlgorithmOrderMapper.selectById(orderId);
        if (algorithmOrder == null) {
            return RestResult.genFailResult("查询订单信息为空");
        }
        //打印订单信息
        log.info("订单信息:{}", algorithmOrder);
        // 拼装成json字符串存放入库，拼装回单信息（orderResult）
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("bizId", gdaiAlgorithmOrderVo.getBizId());
        jsonObject.put("crmOrderId", algorithmOrder.getCrmOrderId());
        jsonObject.put("orderStatus", orderStatus);
        jsonObject.put("orderStatusReason", orderStatusReason);
        jsonObject.put("url", gdaiAlgorithmOrderVo.getUrl());
        jsonObject.put("taskCode", gdaiAlgorithmOrderVo.getTaskCode());
        // 将JSONObject实例转换为JSON字符串
        String jsonString = jsonObject.toJSONString();
        //1.更新订单信息
        gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, orderStatus, orderStatusReason, new Date(), jsonString));
        try {
            //打印调用回单接口参数
            log.info("回单接口参数:{}", jsonObject);
            //2.调接口回单
            RestResult restResult = FeignServiceHelper.reflowOrderResult(userClient, jsonObject);
            //                RestResult restResult = new RestResult();
            //                restResult.setCode("200");
            if (restResult == null) {
                gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单失败", new Date()));
            } else {
                //回单成功更新回单状态
                String code = restResult.getCode();
                String message = restResult.getMessage();
                if (code.equals("200")) {
                    gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单成功", new Date()));
                } else {
                    gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单失败：" + message, new Date()));
                }
            }
        } catch (Exception e) {
            log.info("回单接口调用异常:", e);
            gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单异常：" + e.getMessage(), new Date()));
        }
        return RestResult.genSuccessResult("更新订单信息成功");
    } catch (Exception e) {
        log.info("更新订单信息异常", e);
        gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "5", e.getMessage(), new Date()));
        return RestResult.genFailResult("更新订单信息异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmOrderService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为receiveNotice的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult receiveNotice(JSONObject json) {
    log.info("GdaiAlgorithmOrderServiceImpl.receiveNotice params: [{}]", JSON.toJSONString(json));
    if (json == null) {
        return RestResult.genFailResult("jsonObject is null");
    }
    if (json.size() == 0) {
        return RestResult.genFailResult("jsonObject is empty");
    }
    //更新至订单表，并回单给请求方
    //taskReqId由调用方送过来
    String taskReqId = json.get("taskReqId").toString();
    String taskCode = json.get("taskCode").toString();
    String url = json.getString("url");
    String orderStatus = "3";
    String orderStatusReason = "处理成功";
    // 拼装成json字符串存放入库
    JSONObject jsonObject = new JSONObject();
    jsonObject.put("bizId", taskReqId);
    jsonObject.put("orderStatus", orderStatus);
    jsonObject.put("orderStatusReason", orderStatusReason);
    jsonObject.put("taskCode", taskCode);
    jsonObject.put("url", url);
    //根据taskReqId和orderOperation查询订单号
    GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
    gdaiAlgorithmOrder.setOrderOperation("1");
    gdaiAlgorithmOrder.setBizId(taskReqId);
    GdaiAlgorithmOrder algorithmOrder = gdaiAlgorithmOrderMapper.selectOne(gdaiAlgorithmOrder);
    if (algorithmOrder == null) {
        return RestResult.genFailResult("未查询到相关订单信息");
    }
    Long orderId = algorithmOrder.getOrderId();
    //获取crm订单号一并回单
    String crmOrderId = algorithmOrder.getCrmOrderId();
    jsonObject.put("crmOrderId", crmOrderId);
    // 将JSONObject实例转换为JSON字符串
    String jsonString = jsonObject.toJSONString();
    //查询成功，订单状态置为成功
    gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "3", "处理成功", jsonString, new Date()));
    try {
        //调接口回单
        RestResult restResult = FeignServiceHelper.reflowOrderResult(userClient, jsonObject);
        //            RestResult restResult = new RestResult();
        //            restResult.setCode("200");
        if (restResult == null) {
            gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单失败", new Date()));
        } else {
            //回单成功更新回单状态
            String code = restResult.getCode();
            String message = restResult.getMessage();
            if (code.equals("200")) {
                gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单成功", new Date()));
            } else {
                gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单失败：" + message, new Date()));
            }
        }
    } catch (Exception e) {
        log.info("回单接口调用异常:", e);
        gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "回单失败：" + e.getMessage(), new Date()));
    }
    return RestResult.genSuccessResult("接收成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmOrderService
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为parameterAssembly的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 参数拼装
     *
     * @param gdaiAlgorithmOrder
     * @return
     */
private JSONObject parameterAssembly(GdaiAlgorithmOrder gdaiAlgorithmOrder) {
    log.info("GdaiAlgorithmOrderServiceImpl.parameterAssembly params: [{}]", JSON.toJSONString(gdaiAlgorithmOrder));
    JSONObject jsonObject;
    try {
        String orderType = gdaiAlgorithmOrder.getOrderType();
        String orderDeployPool = gdaiAlgorithmOrder.getOrderDeployPool();
        if (orderType.equals("1")) {
            //1-模型部署
            if (orderDeployPool.equals("1")) {
                //本地资源部署
                jsonObject = localParameterAssembly(gdaiAlgorithmOrder);
                return jsonObject;
            } else if (orderDeployPool.equals("2")) {
                //多云管资源部署
                jsonObject = iscpParameterAssembly(gdaiAlgorithmOrder);
                return jsonObject;
            } else if (orderDeployPool.equals("3")) {
                //集团资源部署
            } else {
                return null;
            }
        } else {
            return null;
        }
    } catch (Exception e) {
        log.info("参数组装异常:", e);
    }
    return null;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.service.GdaiAlgorithmOrderService
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为localParameterAssembly的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 本地部署参数组装
     *
     * @param gdaiAlgorithmOrder
     * @return
     */
private JSONObject localParameterAssembly(GdaiAlgorithmOrder gdaiAlgorithmOrder) {
    String orderOperation = gdaiAlgorithmOrder.getOrderOperation();
    JSONObject orderContent = gdaiAlgorithmOrder.getOrderContent();
    String orderSource = gdaiAlgorithmOrder.getOrderSource();
    JSONObject json = new JSONObject();
    if (orderOperation.equals("1")) {
        //新增
        json.put("servingName", orderContent.get("servingName"));
        json.put("servingType", orderContent.get("servingType"));
        json.put("servingDesc", orderContent.get("servingDesc"));
        json.put("shareFlag", "0");
        json.put("creatorId", orderContent.get("creatorId"));
        json.put("projectId", orderContent.get("projectId"));
        json.put("deployName", orderContent.get("deployName"));
        json.put("imageId", orderContent.get("imageId"));
        json.put("modelDeployType", orderContent.get("modelDeployType"));
        json.put("harborImageId", orderContent.get("harborImageId"));
        json.put("commandAndArgs", orderContent.get("commandAndArgs"));
        json.put("remarks", orderContent.get("remarks"));
        json.put("shareFlag", orderContent.get("shareFlag"));
        json.put("creatorId", orderContent.get("creatorId"));
        json.put("projectId", orderContent.get("projectId"));
        json.put("processUnitType", orderContent.get("processUnitType"));
        json.put("core", orderContent.get("core"));
        json.put("memorySize", orderContent.get("memorySize"));
        json.put("gpuSize", orderContent.get("gpuSize"));
        if (orderSource.equals("1")) {
            //1-CRM下单
            json.put("deploySource", "2");
        }
    } else if (orderOperation.equals("2")) {
        //修改
        json.put("servingId", orderContent.get("servingId"));
        json.put("servingName", orderContent.get("servingName"));
        json.put("servingType", orderContent.get("servingType"));
        json.put("servingDesc", orderContent.get("servingDesc"));
        json.put("shareFlag", "0");
        json.put("creatorId", orderContent.get("creatorId"));
        json.put("projectId", orderContent.get("projectId"));
        json.put("deployName", orderContent.get("deployName"));
        json.put("imageId", orderContent.get("imageId"));
        json.put("modelDeployType", orderContent.get("modelDeployType"));
        json.put("harborImageId", orderContent.get("harborImageId"));
        json.put("commandAndArgs", orderContent.get("commandAndArgs"));
        json.put("remarks", orderContent.get("remarks"));
        json.put("shareFlag", orderContent.get("shareFlag"));
        json.put("creatorId", orderContent.get("creatorId"));
        json.put("projectId", orderContent.get("projectId"));
        json.put("processUnitType", orderContent.get("processUnitType"));
        json.put("core", orderContent.get("core"));
        json.put("memorySize", orderContent.get("memorySize"));
        json.put("gpuSize", orderContent.get("gpuSize"));
        if (orderSource.equals("1")) {
            //1-CRM下单
            json.put("deploySource", "2");
        }
    } else if (orderOperation.equals("3")) {
        //删除
        json.put("servingId", orderContent.get("servingId"));
        json.put("projectId", orderContent.get("projectId"));
    } else if (orderOperation.equals("4")) {
        //扩缩容
        json.put("servingId", orderContent.get("servingId"));
        json.put("replicas", orderContent.get("replicas"));
    }
    return json;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为iscpParameterAssembly的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 多云管参数组装
     *
     * @param gdaiAlgorithmOrder
     * @return
     */
private JSONObject iscpParameterAssembly(GdaiAlgorithmOrder gdaiAlgorithmOrder) {
    String orderOperation = gdaiAlgorithmOrder.getOrderOperation();
    JSONObject orderContent = gdaiAlgorithmOrder.getOrderContent();
    JSONObject json = new JSONObject();
    if (orderOperation.equals("1")) {
        //新增
        // 组装resInfoDto
        JSONObject resInfoDto = new JSONObject();
        resInfoDto.put("harborUrl", orderContent.get("harborUrl"));
        resInfoDto.put("imageServerUrl", orderContent.get("imageServerUrl"));
        resInfoDto.put("imageServerPort", orderContent.get("imageServerPort"));
        JSONObject resourceSpec = new JSONObject();
        resourceSpec.put("disk", orderContent.get("disk"));
        resourceSpec.put("memory", orderContent.get("memory"));
        resourceSpec.put("cpu", orderContent.get("cpu"));
        resourceSpec.put("gpu", orderContent.get("gpu"));
        resInfoDto.put("resourceSpec", resourceSpec);
        resInfoDto.put("instNum", orderContent.get("instNum"));
        resInfoDto.put("imageName", orderContent.get("imageName"));
        resInfoDto.put("imageTag", orderContent.get("imageTag"));
        resInfoDto.put("commands", orderContent.get("commands"));
        resInfoDto.put("args", orderContent.get("args"));
        resInfoDto.put("useHarbor", orderContent.get("useHarbor"));
        resInfoDto.put("architecture", orderContent.get("architecture"));
        json.put("resInfoDto", resInfoDto);
        // 组装taskInfoDto
        JSONObject taskInfoDto = new JSONObject();
        taskInfoDto.put("taskName", orderContent.get("taskName"));
        taskInfoDto.put("gpuType", orderContent.get("gpuType"));
        taskInfoDto.put("taskType", orderContent.get("taskType"));
        taskInfoDto.put("taskDetailType", orderContent.get("taskDetailType"));
        taskInfoDto.put("taskDec", orderContent.get("taskDec"));
        taskInfoDto.put("areaCode", orderContent.get("areaCode"));
        json.put("taskInfoDto", taskInfoDto);
        // 组装policyInfoDto
        JSONObject policyInfoDto = new JSONObject();
        policyInfoDto.put("policyCode", orderContent.get("policyCode"));
        json.put("policyInfoDto", policyInfoDto);
        //当策略为specifyNode或pecifyLabel必填
        String policyCode = policyInfoDto.getString("policyCode");
        if (policyCode.equals("specifyNode") || policyCode.equals("specifyLabel")) {
            json.put("clusterId", orderContent.get("clusterId"));
        }
        //当策略为specifyNode必填
        if (policyCode.equals("specifyNode")) {
            json.put("hostId", orderContent.get("hostId"));
        }
        // 添加其他必填字段
        json.put("namespace", orderContent.get("namespace"));
        json.put("systemId", systemId);
        json.put("productCode", orderContent.get("productCode"));
        json.put("operType", "add");
        json.put("taskReqId", createTaskReqId(orderOperation));
        json.put("userId", userId);
        json.put("tenantId", tenantId);
    } else if (orderOperation.equals("2")) {
        //修改
        json.put("taskReqId", createTaskReqId(orderOperation));
        json.put("harborUrl", orderContent.get("harborUrl"));
        json.put("imageServerUrl", orderContent.get("imageServerUrl"));
        json.put("imageServerPort", orderContent.get("imageServerPort"));
        //taskCode是新增部署时的taskReqId
        json.put("taskCode", orderContent.get("taskCode"));
        json.put("taskName", orderContent.get("taskName"));
        json.put("taskType", orderContent.get("taskType"));
        json.put("taskDec", orderContent.get("taskDec"));
        json.put("taskInstanceNum", orderContent.get("taskInstanceNum"));
        json.put("taskDetailType", orderContent.get("taskDetailType"));
        json.put("systemId", systemId);
        json.put("productCode", orderContent.get("productCode"));
        json.put("userId", userId);
        json.put("tenantId", tenantId);
        json.put("gpuType", orderContent.get("gpuType"));
        //组装resourceSpec
        JSONObject resourceSpec = new JSONObject();
        resourceSpec.put("cpu", orderContent.get("cpu"));
        resourceSpec.put("gpu", orderContent.get("gpu"));
        resourceSpec.put("memory", orderContent.get("memory"));
        resourceSpec.put("disk", orderContent.get("disk"));
        json.put("resourceSpec", resourceSpec);
    } else if (orderOperation.equals("3")) {
        //删除
        //taskCode是新增部署时的taskReqId
        json.put("taskCode", orderContent.get("taskCode"));
        json.put("taskReqId", createTaskReqId(orderOperation));
    } else if (orderOperation.equals("4")) {
        //扩缩容
        json.put("replicas", orderContent.get("replicas"));
        json.put("taskReqId", createTaskReqId(orderOperation));
        //taskCode是新增部署时的taskReqId,放在入参里面用来便于扩缩容之后查询部署结果使用
        //            json.put("taskCode", orderContent.get("taskCode"));
        json.put("productCode", orderContent.get("productCode"));
        json.put("systemId", systemId);
        json.put("userId", userId);
        json.put("tenantId", tenantId);
        json.put("creatorId", gdaiAlgorithmOrder.getCreatorId());
        json.put("servingType", orderContent.get("servingType"));
        json.put("areaCode", orderContent.get("areaCode"));
        json.put("orderAlgorithmId", orderContent.get("orderAlgorithmId"));
    }
    return json;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
/**
 * 多云管系统ID
 */
@Value("${icsp.systemId}")
private String systemId;
/**
 * 多云管用户Id
 */
@Value("${icsp.userId}")
private String userId;
/**
 * 多云管租户Id
 */
@Value("${icsp.tenantId}")
private String tenantId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAlgorithmOrderServiceImpl中有一个名为createTaskReqId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 生成任务单号
     *
     * @param orderOperation
     * @return
     */
private String createTaskReqId(String orderOperation) {
    String dateToStr = DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
    if ("1".equals(orderOperation)) {
        //新增任务单号
        dateToStr = "10" + dateToStr;
    } else if ("2".equals(orderOperation)) {
        //修改任务单号
        dateToStr = "20" + dateToStr;
    } else if ("3".equals(orderOperation)) {
        //删除任务单号
        dateToStr = "30" + dateToStr;
    } else if ("4".equals(orderOperation)) {
        //扩缩容任务单号
        dateToStr = "40" + dateToStr;
    }
    return dateToStr;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.DateUtil
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoManageServiceImpl中有一个名为upload的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult upload(GdaiAutoManageVo gdaiAutoManageVo) {
    log.info("GdaiAutoManageServiceImpl.upload");
    MultipartFile file = gdaiAutoManageVo.getFile();
    if (file == null) {
        return RestResult.genFailResult("上传文件不能为空");
    }
    try {
        //获取文件名称
        String originalFilename = file.getOriginalFilename();
        //校验上传图片类型
        boolean validImageExtension = FileUtil.isValidImageExtension(originalFilename);
        if (!validImageExtension) {
            return RestResult.genFailResult("上传图片必须为jpg,png,或jpeg中的一种");
        }
        //拼装封面图片保存路径
        String destPath = cephUploadPath + GdaiConstant.AUTO_TRAIN_PIC;
        //上传之前检查该文件是否已存在
        List<GdaiAutoManage> list = gdaiAutoManageMapper.selectList(new EntityWrapper<GdaiAutoManage>().eq("image_url", destPath + originalFilename));
        if (list != null && list.size() > 0) {
            return RestResult.genFailResult("已存在同名图片");
        }
        FileUtil.createDir(destPath);
        //上传文件到指定目录
        File path = FileUtils.getFile(destPath + originalFilename);
        file.transferTo(path);
        return RestResult.genSuccessResult(destPath + originalFilename);
    } catch (Exception e) {
        log.info("上传图片异常", e);
        return RestResult.genFailResult("上传图片异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.service.GdaiAutoManageService
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.io.FileUtils
org.springframework.stereotype.Service
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.List
### 类级别的变量
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoManageServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiAutoManage gdaiAutoManage) {
    log.info("GdaiAutoManageServiceImpl.add params: [{}]", JSON.toJSONString(gdaiAutoManage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    String autoTrainName = gdaiAutoManage.getAutoTrainName();
    String dataType = gdaiAutoManage.getDataType();
    String type = gdaiAutoManage.getType();
    String imageUrl = gdaiAutoManage.getImageUrl();
    String autoTrainDesc = gdaiAutoManage.getAutoTrainDesc();
    String ymlContent = gdaiAutoManage.getYmlContent();
    if (StringUtils.isBlank(autoTrainName)) {
        return RestResult.genFailResult("自训练名称不能为空");
    }
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据类型不能为空");
    }
    if (StringUtils.isBlank(type)) {
        return RestResult.genFailResult("任务类型不能为空");
    }
    if (StringUtils.isBlank(imageUrl)) {
        return RestResult.genFailResult("图片存储路径不能为空");
    }
    if (StringUtils.isBlank(autoTrainDesc)) {
        return RestResult.genFailResult("自训练描述不能为空");
    }
    if (StringUtils.isBlank(ymlContent)) {
        return RestResult.genFailResult("自训练模板不能为空");
    }
    try {
        Date curDate = new Date();
        gdaiAutoManage.setCreatorId(userId);
        gdaiAutoManage.setCreateTime(curDate);
        gdaiAutoManage.setModifyTime(curDate);
        gdaiAutoManageMapper.insert(gdaiAutoManage);
    } catch (Exception e) {
        log.info("新增自训练信息异常", e);
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.service.GdaiAutoManageService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoManageServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiAutoManage gdaiAutoManage) {
    log.info("GdaiAutoManageServiceImpl.update params: [{}]" + JSON.toJSONString(gdaiAutoManage));
    Long autoManageId = gdaiAutoManage.getAutoManageId();
    if (autoManageId == null) {
        RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        checkGdaiAutoManage(user, autoManageId);
        //            //修改之前检查信息是否存在
        //            GdaiAutoManage autoManage = gdaiAutoManageMapper.selectById(autoManageId);
        //            if (autoManage == null) {
        //                return RestResult.genFailResult("该自训练信息不存在");
        //            }
        Date curDate = new Date();
        gdaiAutoManage.setModifyTime(curDate);
        gdaiAutoManageMapper.updateById(gdaiAutoManage);
    } catch (Exception e) {
        log.info("修改自训练信息异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.service.GdaiAutoManageService
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoManageServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiAutoManage gdaiAutoManage) {
    log.info("GdaiAutoManageServiceImpl.delete params: [{}]" + JSON.toJSONString(gdaiAutoManage));
    Long autoManageId = gdaiAutoManage.getAutoManageId();
    if (autoManageId == null) {
        RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        GdaiAutoManage autoManage = checkGdaiAutoManage(user, autoManageId);
        //            //删除之前检查信息是否存在
        //            GdaiAutoManage autoManage = gdaiAutoManageMapper.selectById(autoManageId);
        //            if (autoManage == null) {
        //                return RestResult.genFailResult("该自训练信息不存在");
        //            }
        //删除对应图片
        String imageUrl = autoManage.getImageUrl();
        if (StringUtils.isNotBlank(imageUrl)) {
            FileUtil.deleteFile(imageUrl);
        }
        gdaiAutoManageMapper.deleteById(autoManageId);
    } catch (Exception e) {
        log.info("删除自训练信息异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.service.GdaiAutoManageService
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoManageServiceImpl中有一个名为queryById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryById(GdaiAutoManage gdaiAutoManage) {
    log.info("GdaiAutoManageServiceImpl.queryById params: [{}]" + JSON.toJSONString(gdaiAutoManage));
    Long autoManageId = gdaiAutoManage.getAutoManageId();
    if (autoManageId == null) {
        RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        GdaiAutoManage autoManage = checkGdaiAutoManage(user, autoManageId);
        //            //检查信息是否存在
        //            GdaiAutoManage autoManage = gdaiAutoManageMapper.selectById(autoManageId);
        //            if (autoManage == null) {
        //                return RestResult.genFailResult("该自训练信息不存在");
        //            }
        return RestResult.genSuccessResult(autoManage);
    } catch (Exception e) {
        log.info("查询自训练信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.service.GdaiAutoManageService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoManageServiceImpl中有一个名为queryAutoList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAutoList(GdaiAutoManageVo gdaiAutoManageVo) throws Exception {
    log.info("GdaiAutoManageServiceImpl.queryAutoList params: [{}]" + JSON.toJSONString(gdaiAutoManageVo));
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    List<GdaiAutoManageVo> list = new ArrayList<>();
    Page<GdaiAutoManage> gdaiAutoManagePage = gdaiAutoManageService.selectPage(new Page<>(gdaiAutoManageVo.getPageNumber(), gdaiAutoManageVo.getPageCount()), new EntityWrapper<GdaiAutoManage>().orderDesc(desc));
    if (gdaiAutoManagePage != null && gdaiAutoManagePage.getRecords().size() > 0) {
        List<GdaiAutoManage> records = gdaiAutoManagePage.getRecords();
        for (GdaiAutoManage gdaiAutoManage : records) {
            gdaiAutoManageVo = new GdaiAutoManageVo();
            //根据imageUrl下载对应文件流并转换为base64
            if (StringUtils.isNotBlank(gdaiAutoManage.getImageUrl())) {
                String base64 = FileUtil.getFileStream2Base64(gdaiAutoManage.getImageUrl());
                gdaiAutoManageVo.setPicBase64(base64);
            }
            BeanUtils.copyProperties(gdaiAutoManage, gdaiAutoManageVo);
            list.add(gdaiAutoManageVo);
        }
    }
    UiPage<GdaiAutoManageVo> uiPage = new UiPage<>();
    uiPage.setTotal(gdaiAutoManagePage.getTotal());
    uiPage.setPageSize(gdaiAutoManagePage.getSize());
    uiPage.setPages(gdaiAutoManagePage.getPages());
    uiPage.setPageNum(gdaiAutoManagePage.getCurrent());
    uiPage.setList(list);
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.service.GdaiAutoManageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.GdaiAutoManageVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiAutoManageService gdaiAutoManageService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoManageServiceImpl中有一个名为checkGdaiAutoManage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiAutoManage checkGdaiAutoManage(User user, Long autoManageId) throws TrainginCenterException {
    GdaiAutoManage gdaiAutoManage = gdaiAutoManageMapper.selectById(autoManageId);
    if (gdaiAutoManage == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色(超级管理员角色)
        boolean aiGroupAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是管理员
        if (!aiGroupAdminRole) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiAutoManage.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return gdaiAutoManage;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
### 类级别的变量
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为updateStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateStatus(GdaiAutoTraining gdaiAutoTraining) {
    log.info("GdaiAutoTrainingServiceImpl.updateStatus params: [{}]", JSON.toJSONString(gdaiAutoTraining));
    Long autoTrainId = gdaiAutoTraining.getAutoTrainId();
    Long trainSetId = gdaiAutoTraining.getTrainSetId();
    String status = gdaiAutoTraining.getStatus();
    if (autoTrainId == null) {
        return RestResult.genFailResult("自训练ID不能为空");
    }
    if (trainSetId == null) {
        return RestResult.genFailResult("自训练组ID不能为空");
    }
    if (StringUtils.isBlank(status)) {
        return RestResult.genFailResult("状态不能为空");
    }
    try {
        GdaiAutoTrainingSet gdaiAutoTrainingSet = gdaiAutoTrainingSetMapper.selectById(trainSetId);
        if (gdaiAutoTrainingSet == null) {
            return RestResult.genFailResult("自训练组信息为空");
        }
        gdaiAutoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
        if (gdaiAutoTraining == null) {
            return RestResult.genFailResult("自训练记录不存在");
        }
        Date date = new Date();
        //修改自训练任务状态
        gdaiAutoTrainingMapper.updateById(new GdaiAutoTraining(autoTrainId, status, date));
        //修改自训练组任务状态
        GdaiAutoTrainingSet autoTrainingSet = new GdaiAutoTrainingSet();
        autoTrainingSet.setTrainSetId(trainSetId);
        autoTrainingSet.setStatus(status);
        autoTrainingSet.setModifyTime(date);
        gdaiAutoTrainingSetMapper.updateById(autoTrainingSet);
    } catch (Exception e) {
        log.info("修改异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiAutoTraining gdaiAutoTraining) throws TrainginCenterException {
    log.info("GdaiAutoTrainingServiceImpl.updateShareFlag params: [{}]", JSON.toJSONString(gdaiAutoTraining));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //        Long userId = user.getId();
    Long autoTrainId = gdaiAutoTraining.getAutoTrainId();
    String shareFlag = gdaiAutoTraining.getShareFlag();
    if (autoTrainId == null) {
        return RestResult.genFailResult("智能训练ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    checkGdaiAutoTraining(user, autoTrainId, false);
    //        GdaiAutoTraining autoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
    //        if (autoTraining == null) {
    //            return RestResult.genFailResult("该记录不存在");
    //        }
    //        //修改之前判断当前修改人是否和创建人一致（该条记录的创建者才有修改权限）
    //        Long creatorId = autoTraining.getCreatorId();
    //        if (!creatorId.equals(userId)) {
    //            return RestResult.genFailResult("非创建者不能修改该状态");
    //        }
    GdaiAutoTraining training = new GdaiAutoTraining();
    training.setAutoTrainId(autoTrainId);
    training.setShareFlag(shareFlag);
    training.setModifyTime(new Date());
    gdaiAutoTrainingMapper.updateById(training);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiAutoTrainingVo gdaiAutoTrainingVo) {
    log.info("GdaiAutoTrainingServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiAutoTrainingVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long autoTrainId = gdaiAutoTrainingVo.getAutoTrainId();
    if (autoTrainId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    String status = null;
    try {
        //删除之前检查是否存在
        //修复水平越权问题
        GdaiAutoTraining autoTraining = checkGdaiAutoTraining(user, autoTrainId, false);
        //            GdaiAutoTraining autoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
        if (autoTraining != null) {
            //                //判断用户是否是超级管理员,如果是超管则直接删除,如果不是超管,删除之前判断当前用户是否和创建人一致（该条记录的创建者才有删除权限）
            //                Boolean superAdminRole = CommonTools.checkDeletePermission(request, userId, autoTraining.getCreatorId());
            //                if (!superAdminRole) {
            //                    return RestResult.genFailResult("非创建者不能删除该记录");
            //                }
            String jobName = autoTraining.getJobName();
            String podName = autoTraining.getPodName();
            String namespace = autoTraining.getNameSpace();
            status = autoTraining.getStatus();
            if (StringUtils.isNotBlank(jobName) && StringUtils.isNotBlank(namespace)) {
                //删除job
                ApiClient client = k8sInit2.getConnection();
                BatchV1Api appsInstance = new BatchV1Api(client);
                V1JobList v1JobList = appsInstance.listNamespacedJob(namespace, null, null, null, null, null, null, null, null, null, null);
                List<V1Job> items = v1JobList.getItems();
                for (V1Job v1Job : items) {
                    String name = v1Job.getMetadata().getName();
                    if (jobName.equals(name)) {
                        appsInstance.deleteNamespacedJob(jobName, namespace, null, null, 0, null, "", new V1DeleteOptions());
                        break;
                    }
                }
            }
            if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(namespace)) {
                //删除pod
                ApiClient client = k8sInit2.getConnection();
                CoreV1Api api = new CoreV1Api(client);
                V1PodList v1PodList = api.listNamespacedPod(namespace, null, null, null, null, null, null, null, null, null, null);
                List<V1Pod> items = v1PodList.getItems();
                for (V1Pod v1Pod : items) {
                    String name = v1Pod.getMetadata().getName();
                    if (podName.equals(name)) {
                        api.deleteNamespacedPod(podName, namespace, null, null, 0, null, "", new V1DeleteOptions());
                        break;
                    }
                }
            }
            //刪除对应文件夹
            Long projectId = autoTraining.getProjectId();
            Long trainSetId = autoTraining.getTrainSetId();
            //                String filePath = cephUploadPath + autogluon + projectId + "/" + autoTrainId;
            String filePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.AUTOGLUON + "/" + trainSetId + "/" + autoTrainId;
            FileUtil.deleteFile(FileUtils.getFile(filePath));
            //                //状态为Pending和Running表示任务未结束
            //                log.info("status=" + phaseStatus);
            //                if ("Pending".equals(phaseStatus) || "Running".equals(phaseStatus)) {
            //                    log.info("releaseProject");
            //                    //释放配额
            //                    gdaiProjectService.releaseProject(autoTraining.getProjectId(), "train", autoTraining.getCore(), autoTraining.getMemorySize(), autoTraining.getGpuSize());
            //                    //释放资源
            //                    gdaiNodeInfoService.releaseNode(nodeIp, "train", autoTraining.getCore(), autoTraining.getMemorySize(), autoTraining.getGpuSize());
            //                }
            //根据ID删除
            gdaiAutoTrainingMapper.deleteById(autoTrainId);
            return RestResult.genSuccessResult("删除成功");
        }
    } catch (Exception e) {
        log.info("删除训练模型记录异常", e);
    }
    gdaiAutoTrainingMapper.updateById(new GdaiAutoTraining(autoTrainId, status, new Date()));
    return RestResult.genFailResult("删除异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.Date
java.util.List
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * 自训练存储目录
 */
@Value("${cephUpload.autogluon}")
private String autogluon;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为queryById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryById(GdaiAutoTrainingVo gdaiAutoTrainingVo) {
    log.info("GdaiAutoTrainingServiceImpl.queryById params: [{}]", JSON.toJSONString(gdaiAutoTrainingVo));
    Long autoTrainId = gdaiAutoTrainingVo.getAutoTrainId();
    if (autoTrainId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        GdaiAutoTraining gdaiAutoTraining = checkGdaiAutoTraining(user, autoTrainId, true);
        //            GdaiAutoTraining gdaiAutoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
        //            if (gdaiAutoTraining == null) {
        //                return RestResult.genFailResult("未查询到该训练任务");
        //            }
        BeanUtils.copyProperties(gdaiAutoTraining, gdaiAutoTrainingVo);
        Long trainSetId = gdaiAutoTraining.getTrainSetId();
        GdaiAutoTrainingSet gdaiAutoTrainingSet = gdaiAutoTrainingSetMapper.selectById(trainSetId);
        if (gdaiAutoTrainingSet == null) {
            return RestResult.genFailResult("自训练组信息为空");
        }
        gdaiAutoTrainingVo.setTrainName(gdaiAutoTrainingSet.getTrainName());
        User userInfo = FeignServiceHelper.getUserInfoById(userClient, gdaiAutoTraining.getCreatorId());
        if (userInfo != null) {
            gdaiAutoTrainingVo.setCreatorName(userInfo.getUsername());
        }
        //获取封面图
        Long autoManageId = gdaiAutoTraining.getAutoManageId();
        GdaiAutoManage gdaiAutoManage = gdaiAutoManageMapper.selectById(autoManageId);
        if (gdaiAutoManage == null) {
            return RestResult.genFailResult("获取封面图失败");
        }
        //根据imageUrl下载对应文件流并转换为base64
        String imageUrl = gdaiAutoManage.getImageUrl();
        if (StringUtils.isNotBlank(imageUrl)) {
            String base64 = FileUtil.getFileStream2Base64(gdaiAutoManage.getImageUrl());
            gdaiAutoTrainingVo.setPicBase64(base64);
            gdaiAutoTrainingVo.setImageUrl(imageUrl);
        }
        //获取指标输出路径，解析指标文件
        String modelSavePath = gdaiAutoTraining.getModelSavePath();
        if (StringUtils.isNotBlank(modelSavePath)) {
            String evalPath = modelSavePath + "/eval_out/eval.txt";
            File file = FileUtils.getFile(evalPath);
            if (file.exists() && file.isFile()) {
                String type = gdaiAutoManage.getType();
                if ("txtEntity".equalsIgnoreCase(type)) {
                    //读取文件并解析
                    LineIterator lineIterator = FileUtils.lineIterator(file, "UTF-8");
                    while (lineIterator.hasNext()) {
                        String line = lineIterator.nextLine();
                        JSONObject jsonObject = JSONObject.parseObject(line);
                        BigDecimal overall_recall = (BigDecimal) jsonObject.get("overall_recall");
                        BigDecimal overall_precision = (BigDecimal) jsonObject.get("overall_precision");
                        String recall = percentInstance(overall_recall, 2);
                        String precision = percentInstance(overall_precision, 2);
                        gdaiAutoTrainingVo.setRecall(recall);
                        gdaiAutoTrainingVo.setPrecision(precision);
                    }
                } else if ("imgcls".equalsIgnoreCase(type)) {
                    //读取文件并解析
                    LineIterator lineIterator = FileUtils.lineIterator(file, "UTF-8");
                    while (lineIterator.hasNext()) {
                        String line = lineIterator.nextLine();
                        JSONObject jsonObject = JSONObject.parseObject(line);
                        Set<String> keys = jsonObject.keySet();
                        for (String key : keys) {
                            BigDecimal accuracy = (BigDecimal) jsonObject.get(key);
                            String precision = percentInstance(accuracy, 2);
                            gdaiAutoTrainingVo.setPrecision(precision);
                        }
                    }
                }
            }
        }
        return RestResult.genSuccessResult(gdaiAutoTrainingVo);
    } catch (Exception e) {
        log.info("查询异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.io.FileUtils
org.apache.commons.io.LineIterator
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.math.BigDecimal
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Resource
private UserClient userClient;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为queryListBySetId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryListBySetId(GdaiAutoTrainingVo gdaiAutoTrainingVo) {
    log.info("GdaiAutoTrainingServiceImpl.queryListBySetId params: [{}]", JSON.toJSONString(gdaiAutoTrainingVo));
    Long trainSetId = gdaiAutoTrainingVo.getTrainSetId();
    if (trainSetId == null) {
        return RestResult.genFailResult("组ID不能为空");
    }
    try {
        //获取登录用户信息
        User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
        if (user == null) {
            return RestResult.genFailResult("登录用户信息为空");
        }
        Long userId = user.getId();
        //判断登录用户角色
        //        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(request);
        boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
        if (aiGroupAdminRole) {
            //如果是AI团队管理员则展示所有成员创建的任务
            UiPage<GdaiAutoTrainingVo> uiPage = new UiPage<>();
            List<String> desc = new ArrayList<>();
            desc.add("train_version");
            List<GdaiAutoTrainingVo> list = new ArrayList<>();
            Page<GdaiAutoTraining> gdaiTrainingPage = gdaiAutoTrainingService.selectPage(new Page<>(gdaiAutoTrainingVo.getPageNumber(), gdaiAutoTrainingVo.getPageCount()), new EntityWrapper<GdaiAutoTraining>().eq("train_set_id", trainSetId).orderDesc(desc));
            if (gdaiTrainingPage != null && gdaiTrainingPage.getRecords().size() > 0) {
                List<GdaiAutoTraining> records = gdaiTrainingPage.getRecords();
                for (GdaiAutoTraining gdaiTraining : records) {
                    gdaiAutoTrainingVo = new GdaiAutoTrainingVo();
                    BeanUtils.copyProperties(gdaiTraining, gdaiAutoTrainingVo);
                    User userInfo = FeignServiceHelper.getUserInfoById(userClient, gdaiTraining.getCreatorId());
                    if (userInfo != null) {
                        gdaiAutoTrainingVo.setCreatorName(userInfo.getUsername());
                    }
                    list.add(gdaiAutoTrainingVo);
                }
                uiPage.setTotal(gdaiTrainingPage.getTotal());
                uiPage.setPageSize(gdaiTrainingPage.getSize());
                uiPage.setPages(gdaiTrainingPage.getPages());
                uiPage.setPageNum(gdaiTrainingPage.getCurrent());
                uiPage.setList(list);
            }
            return RestResult.genSuccessResult(uiPage);
        } else {
            UiPage<GdaiAutoTrainingVo> uiPage = new UiPage<>();
            List<String> desc = new ArrayList<>();
            desc.add("train_version");
            List<GdaiAutoTrainingVo> list = new ArrayList<>();
            Page<GdaiAutoTraining> gdaiTrainingPage = gdaiAutoTrainingService.selectPage(new Page<>(gdaiAutoTrainingVo.getPageNumber(), gdaiAutoTrainingVo.getPageCount()), new EntityWrapper<GdaiAutoTraining>().eq("train_set_id", trainSetId).andNew().eq("share_flag", "1").or().eq("creator_id", userId).orderDesc(desc));
            if (gdaiTrainingPage != null && gdaiTrainingPage.getRecords().size() > 0) {
                List<GdaiAutoTraining> records = gdaiTrainingPage.getRecords();
                for (GdaiAutoTraining gdaiTraining : records) {
                    gdaiAutoTrainingVo = new GdaiAutoTrainingVo();
                    BeanUtils.copyProperties(gdaiTraining, gdaiAutoTrainingVo);
                    User userInfo = FeignServiceHelper.getUserInfoById(userClient, gdaiTraining.getCreatorId());
                    if (userInfo != null) {
                        gdaiAutoTrainingVo.setCreatorName(userInfo.getUsername());
                    }
                    list.add(gdaiAutoTrainingVo);
                }
                uiPage.setTotal(gdaiTrainingPage.getTotal());
                uiPage.setPageSize(gdaiTrainingPage.getSize());
                uiPage.setPages(gdaiTrainingPage.getPages());
                uiPage.setPageNum(gdaiTrainingPage.getCurrent());
                uiPage.setList(list);
            }
            return RestResult.genSuccessResult(uiPage);
        }
    } catch (Exception e) {
        log.info("查询异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
com.eshore.gdai.trainingcenter.vo.GdaiAutoTrainingVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingService gdaiAutoTrainingService;
@Resource
private UserClient userClient;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为downloadModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadModel(Long autoTrainId, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiAutoTrainingServiceImpl.downloadModel params: [{}]", JSON.toJSONString(autoTrainId));
    if (autoTrainId == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //根据模型ID查询该模型状态，若已完成训练则可以去对应路径下载训练完模型
        //修复水平越权问题
        GdaiAutoTraining gdaiAutoTraining = checkGdaiAutoTraining(user, autoTrainId, true);
        //            GdaiAutoTraining gdaiAutoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
        //            if (gdaiAutoTraining == null) {
        //                return RestResult.genFailResult("该训练任务不存在");
        //            }
        String status = gdaiAutoTraining.getStatus();
        if (!"Succeeded".equals(status)) {
            return RestResult.genFailResult("训练尚未结束");
        }
        //获取保存模型的存储路径
        String modelSavePath = gdaiAutoTraining.getModelSavePath();
        if (StringUtils.isBlank(modelSavePath)) {
            return RestResult.genFailResult("模型保存路径为空");
        }
        modelSavePath = modelSavePath + "/model_out/";
        String fileName = "autogluon_" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(modelSavePath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Autowired
private HttpServletRequest request;
/**
 * 自训练存储目录
 */
@Value("${cephUpload.autogluon}")
private String autogluon;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为downloadLog的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadLog(Long autoTrainId, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiAutoTrainingServiceImpl.downloadLog params: [{}]", JSON.toJSONString(autoTrainId));
    if (autoTrainId == null) {
        return RestResult.genFailResult("训练ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        GdaiAutoTraining gdaiAutoTraining = checkGdaiAutoTraining(user, autoTrainId, true);
        //            GdaiAutoTraining gdaiAutoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
        //            if (gdaiAutoTraining == null) {
        //                return RestResult.genFailResult("该训练任务不存在");
        //            }
        String jobName = gdaiAutoTraining.getJobName();
        if (StringUtils.isBlank(jobName)) {
            return RestResult.genFailResult("任务名称不能为空");
        }
        String namespace = gdaiAutoTraining.getNameSpace();
        if (StringUtils.isBlank(namespace)) {
            return RestResult.genFailResult("命名空间不能为空");
        }
        String fileName = jobName + "-" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //获取训练日志
        ApiClient client = k8sInit2.getConnection();
        BatchV1Api appsInstance = new BatchV1Api(client);
        CoreV1Api apiInstance = new CoreV1Api(client);
        V1JobList v1JobList = appsInstance.listNamespacedJob(namespace, null, null, null, null, null, null, null, null, null, null);
        if (v1JobList == null) {
            return RestResult.genFailResult("Job不存在");
        }
        List<V1Job> jobList = v1JobList.getItems();
        V1Job v1Job = null;
        for (V1Job job : jobList) {
            String name = job.getMetadata().getName();
            if (jobName.equals(name)) {
                v1Job = job;
            }
        }
        V1JobStatus jobStatus = v1Job != null ? v1Job.getStatus() : null;
        if (jobStatus == null) {
            return RestResult.genFailResult("Job不存在");
        }
        V1Pod pod = getPodByName(k8sInit2, jobName, namespace);
        if (pod == null) {
            return RestResult.genFailResult("Pod不存在");
        }
        // pod完整名称
        String podName = pod.getMetadata().getName();
        String podLogs = apiInstance.readNamespacedPodLog(podName, namespace, null, null, null, null, null, null, null, null, null);
        String date = DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);
        String str = "[ " + date + " ]  " + podLogs;
        //设置response的header
        response.setContentType("text/plain;charset=utf-8");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".log");
        response.getOutputStream().write(str.getBytes());
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
io.kubernetes.client.openapi.models.V1JobStatus
io.kubernetes.client.openapi.models.V1Pod
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为deleteFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteFile(GdaiAutoTrainingVo gdaiAutoTrainingVo) {
    //        log.info("GdaiAutoTrainingServiceImpl.deleteFile params: " + JSON.toJSONString(gdaiAutoTrainingVo));
    //        //获取要删除的目录路径
    //        String targetPath = gdaiAutoTrainingVo.getTargetPath();
    //        if (StringUtils.isBlank(targetPath)) {
    //            return RestResult.genFailResult("存放路径不能为空");
    //        }
    //        try {
    //            if (StringUtils.isNotBlank(targetPath)) {
    //                File file = FileUtils.getFile(targetPath);
    //                if (file.exists()) {
    //                    FileUtil.deleteFile(file);
    //                }
    //            }
    //        } catch (Exception e) {
    //            return RestResult.genFailResult("删除异常");
    //        }
    //        return RestResult.genSuccessResult("删除成功");
    return null;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为getResultUrl的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getResultUrl(Long autoTrainId, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiAutoTrainingServiceImpl.getResultUrl params: " + autoTrainId);
    if (autoTrainId == null) {
        return RestResult.genFailResult("训练ID不能为空");
    }
    try {
        GdaiAutoTraining gdaiAutoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
        if (gdaiAutoTraining == null) {
            return RestResult.genFailResult("该训练任务不存在");
        }
        String autoTrainType = gdaiAutoTraining.getAutoTrainType();
        String modelSavePath = gdaiAutoTraining.getModelSavePath();
        if (StringUtils.isBlank(modelSavePath)) {
            return RestResult.genFailResult("训练指标路径为空");
        }
        if ("1".equals(autoTrainType)) {
            //训练任务
            modelSavePath = modelSavePath + "/eval_out/";
        } else if ("2".equals(autoTrainType)) {
            //预测任务
            modelSavePath = modelSavePath + "/test_out/";
        }
        String fileName = "train_out_" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(modelSavePath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为repeatTrain的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult repeatTrain(GdaiAutoTrainingVo gdaiAutoTrainingVo) throws TrainginCenterException {
    log.info("GdaiAutoTrainingServiceImpl.repeatTrain params: {}", JSON.toJSONString(gdaiAutoTrainingVo));
    Long autoTrainId = gdaiAutoTrainingVo.getAutoTrainId();
    if (autoTrainId == null) {
        return RestResult.genFailResult("训练ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    long userId = user.getId();
    //修复水平越权问题
    GdaiAutoTraining autoTraining = checkGdaiAutoTraining(user, autoTrainId, true);
    //        GdaiAutoTraining autoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
    //        if (autoTraining == null) {
    //            return RestResult.genFailResult("原训练任务信息为空");
    //        }
    Long trainSetId = autoTraining.getTrainSetId();
    autoTraining.setAutoTrainId(null);
    autoTraining.setPodName("");
    autoTraining.setJobName("");
    autoTraining.setNameSpace("");
    autoTraining.setPodLabelSelector("");
    GdaiAutoTraining gdaiAutoTraining = new GdaiAutoTraining();
    BeanUtils.copyProperties(autoTraining, gdaiAutoTraining);
    Long projectId = gdaiAutoTraining.getProjectId();
    Long autoManageId = gdaiAutoTraining.getAutoManageId();
    String autoTrainType = gdaiAutoTraining.getAutoTrainType();
    String datasetSource = gdaiAutoTraining.getDatasetSource();
    String processUnitType = gdaiAutoTraining.getProcessUnitType();
    String core = gdaiAutoTraining.getCore();
    String memorySize = gdaiAutoTraining.getMemorySize();
    String gpuSize = gdaiAutoTraining.getGpuSize();
    Long creatorId = gdaiAutoTraining.getCreatorId();
    try {
        //根据auto_manage_id，auto_train_type，train_set_id，creator_id查询当前最大版本号，若没有则默认版本为1，如果有则自增1
        int maxVersion = gdaiAutoTrainingMapper.getMaxVersion(autoManageId, autoTrainType, trainSetId, creatorId);
        gdaiAutoTraining.setTrainVersion((long) (maxVersion + 1));
        Date curDate = new Date();
        gdaiAutoTraining.setCreatorId(creatorId);
        gdaiAutoTraining.setCreateTime(curDate);
        gdaiAutoTraining.setModifyTime(curDate);
        gdaiAutoTrainingMapper.insert(gdaiAutoTraining);
        Long autoTrainId1 = gdaiAutoTraining.getAutoTrainId();
        //拼装基础路径
        //            String basePath = cephUploadPath + autogluon + projectId + "/" + trainSetId + "/" + autoTrainId1;
        String basePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.AUTOGLUON + "/" + trainSetId + "/" + autoTrainId1;
        //拼装上传数据集路径
        String datasetTrainPath = basePath + "/datasets/trainDataset/";
        String datasetTestPath = basePath + "/datasets/testDataset/";
        //拼装模型保存目录
        String modelSavePath = basePath + "/out";
        gdaiAutoTrainingMapper.updateById(new GdaiAutoTraining(autoTrainId1, datasetTrainPath, datasetTestPath, modelSavePath, new Date()));
        GdaiAutoTraining autoTrainingTemp = gdaiAutoTrainingMapper.selectById(autoTrainId1);
        GdaiAutoTraining training = new GdaiAutoTraining();
        BeanUtils.copyProperties(autoTrainingTemp, training);
        GdaiAutoManage gdaiAutoManage = gdaiAutoManageMapper.selectById(autoManageId);
        if (gdaiAutoManage == null) {
            return RestResult.genFailResult("自训练管理信息为空");
        }
        if ("1".equals(autoTrainType)) {
            String trainYmlContent = gdaiAutoManage.getYmlContent();
            if (StringUtils.isBlank(trainYmlContent)) {
                return RestResult.genFailResult("训练模板不能为空");
            }
            training.setTrainYmlContent(trainYmlContent);
        } else if ("2".equals(autoTrainType)) {
            String reasoningYmlContent = gdaiAutoManage.getReasoningYmlContent();
            if (StringUtils.isBlank(reasoningYmlContent)) {
                return RestResult.genFailResult("推理模板不能为空");
            }
            training.setTrainYmlContent(reasoningYmlContent);
        }
        training.setAutoTrainType(autoTrainType);
        //根据项目ID查询该项目当前资源占用情况
        GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
        if (gdaiProject == null) {
            return RestResult.genFailResult("该项目不存在");
        }
        Long projectCoreNumber = gdaiProject.getProjectCoreNumber();
        Long projectCpuSize = gdaiProject.getProjectCpuSize();
        Long projectGpuSize = gdaiProject.getProjectGpuSize();
        Long usedCoreNumber = gdaiProject.getUsedCoreNumber();
        Long usedCpuSize = gdaiProject.getUsedCpuSize();
        Long usedGpuSize = gdaiProject.getUsedGpuSize();
        //计算项目当前可用资源
        Long freeCoreNumber = projectCoreNumber - usedCoreNumber;
        Long freeCpuSize = projectCpuSize - usedCpuSize;
        Long freeGpuSize = projectGpuSize - usedGpuSize;
        //将用户自定义所需资源与可用资源进行对比
        long applyCore = Long.parseLong(core);
        if (applyCore > freeCoreNumber) {
            return RestResult.genFailResult("所需core超出项目总core");
        }
        String[] ms = memorySize.split("G");
        long applyMemorySize = Long.parseLong(ms[0]) * 1024;
        if (applyMemorySize > freeCpuSize) {
            return RestResult.genFailResult("所需cpu内存大小超出项目总内存大小");
        }
        long applyGpuMemorySize = (Long.parseLong(gpuSize) / 1000) * 1024;
        if (applyGpuMemorySize > freeGpuSize) {
            return RestResult.genFailResult("所需gpu大小超出项目总显存大小");
        }
        //算力大小默认设置为50%
        training.setComputingPower("50");
        training.setStatus("Pending");
        String modelOut = modelSavePath + "/model_out/";
        FileUtil.createDir(modelOut);
        if ("1".equals(autoTrainType)) {
            //训练任务
            String evalOut = modelSavePath + "/eval_out/";
            FileUtil.createDir(evalOut);
        } else if ("2".equals(autoTrainType)) {
            //预测任务
            String testOut = modelSavePath + "/test_out/";
            FileUtil.createDir(testOut);
        }
        training.setDatasetSource(datasetSource);
        training.setProcessUnitType(processUnitType);
        training.setCore(core);
        training.setMemorySize(memorySize);
        //这里默认使用1张卡
        training.setCardNumber(number);
        training.setGpuSize(gpuSize);
        //设置命名空间，按项目划分 gdai-projectId
        training.setNameSpace(GdaiConstant.NAMESPACE_PREFIX + projectId);
        gdaiAutoTrainingMapper.updateById(training);
        //另起线程创建job训练任务
        GdaiAutoTrainingServiceImpl gdaiAutoTrainingServiceImpl = new GdaiAutoTrainingServiceImpl();
        //            uploadThreadPool.execute(new GdaiAutoTrainingServiceImpl.StartTrainJob(k8sClientOperator, gdaiAutoTrainingMapper, gdaiClusterInfoMapper, gdaiNodeInfoMapper, gdaiProjectMapper, k8sInit2, gdaiAutoTrainingServiceImpl, training, gdaiNodeInfoService, gdaiProjectService, projectId));
        gdaiAutoTrainingModelAsyncTask.startAutoTraining(training);
    } catch (Exception e) {
        log.info("创建任务异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("创建任务异常");
    }
    return RestResult.genSuccessResult("创建任务成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Date
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiAutoTrainingService gdaiAutoTrainingService;
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * 自训练存储目录
 */
@Value("${cephUpload.autogluon}")
private String autogluon;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;
@Resource
private GdaiAutoTrainingAsyncTask gdaiAutoTrainingModelAsyncTask;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为deploy的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deploy(GdaiModelDeployVo gdaiModelDeployVo) {
    log.info("GdaiAutoTrainingServiceImpl.deploy params: {}", JSON.toJSONString(gdaiModelDeployVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    try {
        GdaiModelDeploy gdaiModelDeploy = new GdaiModelDeploy();
        BeanUtils.copyProperties(gdaiModelDeployVo, gdaiModelDeploy);
        Long autoTrainId = gdaiModelDeployVo.getAutoTrainId();
        if (autoTrainId == null) {
            return RestResult.genFailResult("训练ID不能为空");
        }
        //修复水平越权问题
        GdaiAutoTraining autoTraining = checkGdaiAutoTraining(user, autoTrainId, true);
        //            GdaiAutoTraining autoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
        //            if (autoTraining == null) {
        //                return RestResult.genFailResult("原训练任务信息为空");
        //            }
        Long trainSetId = autoTraining.getTrainSetId();
        Long trainVersion = autoTraining.getTrainVersion();
        GdaiAutoTrainingSet gdaiAutoTrainingSet = gdaiAutoTrainingSetMapper.selectById(trainSetId);
        if (gdaiAutoTrainingSet == null) {
            return RestResult.genFailResult("原训练组任务信息为空");
        }
        String trainName = gdaiAutoTrainingSet.getTrainName();
        Long autoManageId = autoTraining.getAutoManageId();
        GdaiAutoManage gdaiAutoManage = gdaiAutoManageMapper.selectById(autoManageId);
        if (gdaiAutoManage == null) {
            return RestResult.genFailResult("自训练管理信息为空");
        }
        String deployYmlContent = gdaiAutoManage.getDeployYmlContent();
        gdaiModelDeploy.setPubYmlContent(deployYmlContent);
        //获取模型保存路径
        String modelSavePath = autoTraining.getModelSavePath();
        JSONObject json = new JSONObject();
        json.put("modelSavePath", modelSavePath);
        gdaiModelDeploy.setExtendData(json);
        Long projectId = autoTraining.getProjectId();
        gdaiModelDeploy.setProjectId(projectId);
        String deployName = trainName + "_V" + trainVersion;
        gdaiModelDeploy.setDeployName(deployName);
        //设置命名空间，按项目划分 gdai-projectId
        gdaiModelDeploy.setPubNamespaceName(GdaiConstant.NAMESPACE_PREFIX + projectId);
        String type = gdaiAutoManage.getType();
        String pubUrl = "";
        if ("txtEntity".equalsIgnoreCase(type)) {
            String commandAndArgs = "python /home/autogluon-server.py --model_out=/out/model_out --port=8390";
            gdaiModelDeploy.setCommandAndArgs(commandAndArgs);
            pubUrl = "autogluon_classify";
            gdaiModelDeploy.setPubUrl(pubUrl);
        } else if ("imgcls".equalsIgnoreCase(type)) {
            String commandAndArgs = "python /home/autogluon-server-image.py --model_out=/out/model_out --port=8390";
            gdaiModelDeploy.setCommandAndArgs(commandAndArgs);
            pubUrl = "autogluon_image_classify";
            gdaiModelDeploy.setPubUrl(pubUrl);
        }
        String core = "2";
        gdaiModelDeploy.setCore(core);
        String memorySize = "4G";
        gdaiModelDeploy.setMemorySize(memorySize);
        String gpuSize = "2000";
        gdaiModelDeploy.setGpuSize(gpuSize);
        gdaiModelDeploy.setCreatorId(userId);
        String isCustRes = "1";
        gdaiModelDeploy.setIsCustRes(isCustRes);
        gdaiModelDeploy.setContext("{}");
        gdaiModelDeploy.setServiceUrl("[]");
        if (projectId == null) {
            return RestResult.genFailResult("项目ID不能为空");
        }
        if (StringUtils.isBlank(deployName)) {
            return RestResult.genFailResult("部署名称不能为空");
        }
        if (StringUtils.isBlank(core)) {
            return RestResult.genFailResult("核心数不能为空");
        }
        if (StringUtils.isBlank(memorySize)) {
            return RestResult.genFailResult("内存大小不能为空");
        }
        if (StringUtils.isBlank(gpuSize)) {
            return RestResult.genFailResult("GPU大小不能为空");
        }
        if (StringUtils.isBlank(pubUrl)) {
            return RestResult.genFailResult("接口地址不能为空");
        }
        RestResult limitsOfResources = resourceQuotaService.reachLimitsOfResources("", GdaiConstant.NAMESPACE_PREFIX + projectId, Integer.parseInt(gdaiModelDeploy.getCore()), Integer.parseInt(gdaiModelDeploy.getMemorySize().replace("G", "")), //TBD vcuda-core 待添加字段
        Integer.parseInt("0"), Integer.parseInt(gdaiModelDeploy.getGpuSize()), // 暂时用不到
        Integer.parseInt("0"));
        if (limitsOfResources != null && limitsOfResources.getSuccess() != 0) {
            return RestResult.genFailResult(limitsOfResources.getMessage());
        }
        //算力大小默认设置为50%
        gdaiModelDeploy.setComputingPower("50");
        //这里默认使用卡片数
        gdaiModelDeploy.setCardNumber(number);
        //部署来源：0-常规部署，1-智能部署
        gdaiModelDeploy.setDeploySource("1");
        //解决字段非空约束,默认赋值为空
        gdaiModelDeploy.setPubCntrMsg("");
        gdaiModelDeployMapper.insert(gdaiModelDeploy);
        Long deployId = gdaiModelDeploy.getDeployId();
        gdaiModelDeploy.setDeployId(deployId);
        //修改状态为开始部署
        gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2C", isCustRes, userId, new Date()));
        //另起线程模型部署
        GdaiAutoTrainingServiceImpl gdaiAutoTrainingServiceImpl = new GdaiAutoTrainingServiceImpl();
        //            uploadThreadPool.execute(new GdaiAutoTrainingServiceImpl.StartDeployModel(transactionManager, transactionStatuses, gdaiModelDeployMapper, gdaiClusterInfoMapper, gdaiNodeInfoMapper, gdaiProjectMapper, gdaiProjectService, gdaiModelDeploy, gdaiNodeInfoService, k8sClientOperator, k8sInit2,
        //                    gdaiAutoTrainingServiceImpl, modelSavePath));
        gdaiAutoTrainingModelAsyncTask.startAutoDeploy(gdaiModelDeploy);
    } catch (Exception e) {
        log.info("模型部署异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("模型部署异常");
    }
    return RestResult.genSuccessResult("开始部署");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.util.Date
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiAutoTrainingService gdaiAutoTrainingService;
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
/**
 * 自训练存储目录
 */
@Value("${cephUpload.autogluon}")
private String autogluon;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;
@Resource
private PlatformTransactionManager transactionManager;
@Resource
private GdaiAutoTrainingAsyncTask gdaiAutoTrainingModelAsyncTask;
List<TransactionStatus> transactionStatuses = Collections.synchronizedList(new ArrayList<>());

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为createJobTemplateV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiAutoTraining createJobTemplateV2(GdaiAutoTraining gdaiAutoTraining) {
    String trainYmlContent;
    try {
        //TBD 存量的项目创建namespace
        k8sClientOperator.createNamespaceIfNotExist(gdaiAutoTraining.getNameSpace());
        // 获取yaml模板
        trainYmlContent = gdaiAutoTraining.getTrainYmlContent();
        //替换模板参数
        V1Job yamlJob = YamlUtil.loadObject(trainYmlContent, gdaiAutoTraining, V1Job.class);
        //替换后的yaml
        String yamlJobStr = io.kubernetes.client.util.Yaml.dump(yamlJob);
        //保存yaml
        gdaiAutoTraining.setTrainYmlContent(yamlJobStr);
        log.info("createJob yamlJobStr:\n " + yamlJobStr);
        //创建job
        gdaiAutoTraining = createJobV2(k8sInit2, k8sClientOperator, gdaiAutoTraining, gdaiClusterInfoMapper, gdaiNodeInfoMapper, gdaiProjectMapper, gdaiNodeInfoService, yamlJob);
    } catch (Exception ex) {
        log.error("create k8s job exception:", ex);
        gdaiAutoTraining.setStatus("Unkonwn");
    }
    return gdaiAutoTraining;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util
io.kubernetes.client.openapi.models.V1Job
org.springframework.stereotype.Service
java.util.Map
### 类级别的变量
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为createJobTemplateV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiAutoTraining createJobTemplateV2(K8sClientOperator sClientOperator, K8sInit2 k8sInit2, K8sClientOperator k8sClientOperator, GdaiAutoTraining gdaiAutoTraining, GdaiClusterInfoMapper gdaiClusterInfoMapper, GdaiNodeInfoMapper gdaiNodeInfoMapper, GdaiProjectMapper gdaiProjectMapper, GdaiNodeInfoService gdaiNodeInfoService) {
    String trainYmlContent;
    try {
        //TBD 存量的项目创建namespace
        k8sClientOperator.createNamespaceIfNotExist(gdaiAutoTraining.getNameSpace());
        // 获取yaml模板
        trainYmlContent = gdaiAutoTraining.getTrainYmlContent();
        //替换模板参数
        V1Job yamlJob = YamlUtil.loadObject(trainYmlContent, gdaiAutoTraining, V1Job.class);
        //替换后的yaml
        String yamlJobStr = io.kubernetes.client.util.Yaml.dump(yamlJob);
        //保存yaml
        gdaiAutoTraining.setTrainYmlContent(yamlJobStr);
        log.info("createJob yamlJobStr:\n " + yamlJobStr);
        //创建job
        gdaiAutoTraining = createJobV2(k8sInit2, k8sClientOperator, gdaiAutoTraining, gdaiClusterInfoMapper, gdaiNodeInfoMapper, gdaiProjectMapper, gdaiNodeInfoService, yamlJob);
    } catch (Exception ex) {
        log.error("create k8s job exception:", ex);
        gdaiAutoTraining.setStatus("Unkonwn");
    }
    return gdaiAutoTraining;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util
io.kubernetes.client.openapi.models.V1Job
org.springframework.stereotype.Service
java.util.Map
### 类级别的变量
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为createJobV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private GdaiAutoTraining createJobV2(K8sInit2 k8sInit2, K8sClientOperator k8sClientOperator, GdaiAutoTraining gdaiAutoTraining, GdaiClusterInfoMapper gdaiClusterInfoMapper, GdaiNodeInfoMapper gdaiNodeInfoMapper, GdaiProjectMapper gdaiProjectMapper, GdaiNodeInfoService gdaiNodeInfoService, V1Job body) throws Exception {
    try {
        V1Job v1Job = k8sClientOperator.createJob(body, gdaiAutoTraining.getNameSpace());
        gdaiAutoTraining.setJobName(v1Job.getMetadata().getName());
        gdaiAutoTraining.setPodLabelSelector("app=" + v1Job.getSpec().getSelector().getMatchLabels().get("app"));
        //通过jobName获取对应创建容器的podName
        V1Pod curV1Pod = getPodByName(k8sInit2, gdaiAutoTraining.getJobName(), gdaiAutoTraining.getNameSpace());
        String podName = curV1Pod.getMetadata().getName();
        gdaiAutoTraining.setPodName(podName);
        //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
        gdaiAutoTraining.setStatus(curV1Pod.getStatus().getPhase());
        //查询该容器在那个节点上
        String nodeIp = curV1Pod.getSpec().getNodeName();
        //            gdaiNodeInfoService.applyNode(nodeIp, "train", gdaiAutoTraining.getCore(), gdaiAutoTraining.getMemorySize(), gdaiAutoTraining.getGpuSize());
        if (StringUtils.isBlank(gdaiAutoTraining.getStatus())) {
            gdaiAutoTraining.setStatus("Unkonwn");
        }
    } catch (Exception e) {
        log.info("create job 异常", e);
        throw e;
    }
    return gdaiAutoTraining;
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1Pod
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为getPodByName的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取容器名称
     *
     * @param k8sInit2
     * @param jobName
     * @param namespace
     * @return
     * @throws ApiException
     */
public V1Pod getPodByName(K8sInit2 k8sInit2, String jobName, String namespace) throws ApiException {
    V1Pod realPod = null;
    ApiClient client = k8sInit2.getConnection();
    CoreV1Api apiInstance = new CoreV1Api(client);
    V1PodList v1PodList = apiInstance.listNamespacedPod(namespace, null, null, null, null, null, null, null, null, null, null);
    if (v1PodList != null) {
        String podName;
        List<V1Pod> podList = v1PodList.getItems();
        for (V1Pod v1Pod : podList) {
            String phase = v1Pod.getStatus().getPhase();
            // 排除一些不正常的pod
            if (StringUtils.isBlank(phase) || "Terminating".equals(phase) || ("Failed".equals(phase) && "UnexpectedAdmissionError".equals(v1Pod.getStatus().getReason()))) {
                continue;
            }
            // 由于是kubernetes的job创建的pod，所以pod名会在job名称后面自动加上一串字母，用"-"连接，所以比较时需要去掉后面一串
            podName = v1Pod.getMetadata().getName().substring(0, v1Pod.getMetadata().getName().lastIndexOf("-"));
            if (jobName.equals(podName)) {
                realPod = v1Pod;
                break;
            }
        }
    }
    return realPod;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为percentInstance的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 百分比计算
     *
     * @param number
     * @param min
     * @return
     */
public static String percentInstance(BigDecimal number, Integer min) {
    if (number == null) {
        number = BigDecimal.valueOf(0);
    }
    //获取格式化对象
    NumberFormat nt = NumberFormat.getPercentInstance();
    //设置百分数精确度2即保留两位小数
    nt.setMinimumFractionDigits(min);
    return nt.format(number);
}
### 类导入的包
java.math.BigDecimal
java.text.NumberFormat
### 类级别的变量
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为createPubContainerV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiModelDeploy createPubContainerV2(GdaiModelDeploy gdaiModelDeploy) throws Exception {
    String ymlContent = "";
    try {
        //TBD 存量的项目创建namespace
        k8sClientOperator.createNamespaceIfNotExist(gdaiModelDeploy.getPubNamespaceName());
        //TBD
        gdaiModelDeploy.setCommandAndArgs(gdaiModelDeploy.getCommandAndArgs().replace("${REPLACE_FOR_CNTRPORT}", "8888"));
        Long deployId = gdaiModelDeploy.getDeployId();
        // 1、获取模板
        String ymlContentInImage = gdaiModelDeploy.getPubYmlContent();
        // 和算法提供的模板匹配，目前一个yaml模板包含第一个是deployment,第二个是service的定义
        int indexSplitChars = ymlContentInImage.indexOf("---");
        //替换模型
        log.info("GdaiModelDeploy createContainerV2 GdaiModelDeploy 替换模型：\n" + JSON.toJSONString(gdaiModelDeploy));
        //2.1 deployment模板处理
        String ymlContent4Deployment = ymlContentInImage.substring(0, indexSplitChars);
        log.info("GdaiModelDeploy createContainerV2 Deployment 替换前模板：\n" + ymlContent4Deployment);
        //替换模板参数
        V1Deployment yamlDeployment = YamlUtil.loadObject(ymlContent4Deployment, gdaiModelDeploy, V1Deployment.class);
        //替换后的yaml
        String yamlDeploymentStr = io.kubernetes.client.util.Yaml.dump(yamlDeployment);
        log.info("GdaiModelDeploy createPubContainerV2  Deployment 替换后模板:\n " + yamlDeploymentStr);
        //保存yaml
        ymlContent = yamlDeploymentStr;
        //2.2 service模板处理
        String ymlContent4Service = ymlContentInImage.substring(indexSplitChars + 3);
        log.info("GdaiModelDeploy createContainerV2 Service 替换前模板：\n" + ymlContent4Service);
        //替换模板参数
        V1Service yamlService = YamlUtil.loadObject(ymlContent4Service, gdaiModelDeploy, V1Service.class);
        //替换后的yaml
        String yamlServiceStr = io.kubernetes.client.util.Yaml.dump(yamlService);
        log.info("GdaiModelDeploy createContainerV2 Service 替换后模板:\n " + yamlServiceStr);
        //保存yaml
        ymlContent = (yamlDeploymentStr + "\n" + "---" + "\n" + yamlServiceStr);
        //创建deployment
        gdaiModelDeploy = createDeploymentV2(gdaiModelDeploy, yamlDeployment, k8sClientOperator);
        // 创建完deployment,预留时间给k8s创建 service, 若120秒没创建完， 简单设置为失败
        if (!k8sClientOperator.checkPodStatus(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector(), 300)) {
            log.info("waiting create pod timeout");
            throw new Exception("创建部署Pod容器超时");
        }
        gdaiModelDeploy = createServiceV2(gdaiModelDeploy, yamlService, k8sClientOperator);
        //TBD
        // 创建完deployment,预留时间给k8s创建 service, 若120秒没创建完， 简单设置为失败
        //            long waitTime = 0;
        //            while (true) {
        //                Thread.sleep(10 * 1000);
        //                waitTime = waitTime + 10;
        //                buildCntrMsg("creating", gdaiModelDeploy, k8sClientOperator);
        //                gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                if (checkPodCreated(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector(), k8sInit2)) {
        //                    //创建deployment
        //                    gdaiModelDeploy = createServiceV2(gdaiModelDeploy, yamlService, k8sClientOperator);
        //                    break;
        //                } else {
        //                    if (waitTime > 100) {
        //                        log.info("waiting create pod timeout");
        //                        throw new Exception("等待创建service超时");
        //                    } else {
        //                        continue;
        //                    }
        //                }
        //            }
        buildCntrMsg("success", gdaiModelDeploy, k8sClientOperator);
        Map<String, String> map = getPubUrl(gdaiModelDeploy, gdaiModelDeploy.getPubNodePort(), k8sInit2);
        if (map != null && !map.isEmpty()) {
            gdaiModelDeploy.setPubUrl(map.get("pubUrl"));
            gdaiModelDeploy.setPubPodName(map.get("pubPodName"));
        }
        //5 扣减节点资源
        applyResource(gdaiModelDeploy, gdaiNodeInfoService, k8sClientOperator);
        gdaiModelDeploy.setPubYmlContent(ymlContent);
        //gdaiModelDeploy.setPubCntrMsg("success");
        gdaiModelDeploy.setStatus("S2R");
        gdaiModelDeploy.setModifyTime(new Date());
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        return gdaiModelDeploy;
    } catch (Exception ex) {
        log.error("create k8s deployment exception:", ex);
        gdaiModelDeploy.setPubYmlContent(ymlContent);
        gdaiModelDeploy.setStatus("S2E");
        String cntrMsg = ex.getMessage();
        if (ex.getMessage() != null && ex.getMessage().length() > 200) {
            cntrMsg = ex.getMessage().substring(0, 200);
        }
        //gdaiModelDeploy.setPubCntrMsg(cntrMsg);
        buildCntrMsg(cntrMsg, gdaiModelDeploy, k8sClientOperator);
        gdaiModelDeploy.setModifyTime(new Date());
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //创建service异常，删除对应的pod容器
        String pubDeploymentName = gdaiModelDeploy.getPubDeploymentName();
        String pubNamespaceName = gdaiModelDeploy.getPubNamespaceName();
        if (StringUtils.isNotBlank(pubDeploymentName) && StringUtils.isNotBlank(pubNamespaceName)) {
            // 释放节点资源
            releaseResource(gdaiModelDeploy, gdaiNodeInfoService, k8sClientOperator);
            ApiClient client = k8sInit2.getConnection();
            AppsV1Api api = new AppsV1Api(client);
            try {
                api.deleteNamespacedDeployment(pubDeploymentName, pubNamespaceName, null, null, 0, null, "", new V1DeleteOptions());
            } catch (ApiException e) {
                log.info("删除pod异常", e);
            }
        }
        return gdaiModelDeploy;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1Service
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为createPubContainerV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiModelDeploy createPubContainerV2(GdaiModelDeploy gdaiModelDeploy, GdaiModelDeployMapper gdaiModelDeployMapper, GdaiNodeInfoService gdaiNodeInfoService, K8sInit2 k8sInit2, K8sClientOperator k8sClientOperator) throws Exception {
    String ymlContent = "";
    try {
        //TBD 存量的项目创建namespace
        k8sClientOperator.createNamespaceIfNotExist(gdaiModelDeploy.getPubNamespaceName());
        //TBD
        gdaiModelDeploy.setCommandAndArgs(gdaiModelDeploy.getCommandAndArgs().replace("${REPLACE_FOR_CNTRPORT}", "8888"));
        Long deployId = gdaiModelDeploy.getDeployId();
        // 1、获取模板
        String ymlContentInImage = gdaiModelDeploy.getPubYmlContent();
        // 和算法提供的模板匹配，目前一个yaml模板包含第一个是deployment,第二个是service的定义
        int indexSplitChars = ymlContentInImage.indexOf("---");
        //替换模型
        log.info("GdaiModelDeploy createContainerV2 GdaiModelDeploy 替换模型：\n" + JSON.toJSONString(gdaiModelDeploy));
        //2.1 deployment模板处理
        String ymlContent4Deployment = ymlContentInImage.substring(0, indexSplitChars);
        log.info("GdaiModelDeploy createContainerV2 Deployment 替换前模板：\n" + ymlContent4Deployment);
        //替换模板参数
        V1Deployment yamlDeployment = YamlUtil.loadObject(ymlContent4Deployment, gdaiModelDeploy, V1Deployment.class);
        //替换后的yaml
        String yamlDeploymentStr = io.kubernetes.client.util.Yaml.dump(yamlDeployment);
        log.info("GdaiModelDeploy createPubContainerV2  Deployment 替换后模板:\n " + yamlDeploymentStr);
        //保存yaml
        ymlContent = yamlDeploymentStr;
        //2.2 service模板处理
        String ymlContent4Service = ymlContentInImage.substring(indexSplitChars + 3);
        log.info("GdaiModelDeploy createContainerV2 Service 替换前模板：\n" + ymlContent4Service);
        //替换模板参数
        V1Service yamlService = YamlUtil.loadObject(ymlContent4Service, gdaiModelDeploy, V1Service.class);
        //替换后的yaml
        String yamlServiceStr = io.kubernetes.client.util.Yaml.dump(yamlService);
        log.info("GdaiModelDeploy createContainerV2 Service 替换后模板:\n " + yamlServiceStr);
        //保存yaml
        ymlContent = (yamlDeploymentStr + "\n" + "---" + "\n" + yamlServiceStr);
        //创建deployment
        gdaiModelDeploy = createDeploymentV2(gdaiModelDeploy, yamlDeployment, k8sClientOperator);
        // 创建完deployment,预留时间给k8s创建 service, 若120秒没创建完， 简单设置为失败
        if (!k8sClientOperator.checkPodStatus(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector(), 300)) {
            log.info("waiting create pod timeout");
            throw new Exception("创建部署Pod容器超时");
        }
        gdaiModelDeploy = createServiceV2(gdaiModelDeploy, yamlService, k8sClientOperator);
        //TBD
        // 创建完deployment,预留时间给k8s创建 service, 若120秒没创建完， 简单设置为失败
        //            long waitTime = 0;
        //            while (true) {
        //                Thread.sleep(10 * 1000);
        //                waitTime = waitTime + 10;
        //                buildCntrMsg("creating", gdaiModelDeploy, k8sClientOperator);
        //                gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //                if (checkPodCreated(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector(), k8sInit2)) {
        //                    //创建deployment
        //                    gdaiModelDeploy = createServiceV2(gdaiModelDeploy, yamlService, k8sClientOperator);
        //                    break;
        //                } else {
        //                    if (waitTime > 100) {
        //                        log.info("waiting create pod timeout");
        //                        throw new Exception("等待创建service超时");
        //                    } else {
        //                        continue;
        //                    }
        //                }
        //            }
        buildCntrMsg("success", gdaiModelDeploy, k8sClientOperator);
        Map<String, String> map = getPubUrl(gdaiModelDeploy, gdaiModelDeploy.getPubNodePort(), k8sInit2);
        if (map != null && !map.isEmpty()) {
            gdaiModelDeploy.setPubUrl(map.get("pubUrl"));
            gdaiModelDeploy.setPubPodName(map.get("pubPodName"));
        }
        //5 扣减节点资源
        applyResource(gdaiModelDeploy, gdaiNodeInfoService, k8sClientOperator);
        gdaiModelDeploy.setPubYmlContent(ymlContent);
        //gdaiModelDeploy.setPubCntrMsg("success");
        gdaiModelDeploy.setStatus("S2R");
        gdaiModelDeploy.setModifyTime(new Date());
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        return gdaiModelDeploy;
    } catch (Exception ex) {
        log.error("create k8s deployment exception:", ex);
        gdaiModelDeploy.setPubYmlContent(ymlContent);
        gdaiModelDeploy.setStatus("S2E");
        String cntrMsg = ex.getMessage();
        if (ex.getMessage() != null && ex.getMessage().length() > 200) {
            cntrMsg = ex.getMessage().substring(0, 200);
        }
        //gdaiModelDeploy.setPubCntrMsg(cntrMsg);
        buildCntrMsg(cntrMsg, gdaiModelDeploy, k8sClientOperator);
        gdaiModelDeploy.setModifyTime(new Date());
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        //创建service异常，删除对应的pod容器
        String pubDeploymentName = gdaiModelDeploy.getPubDeploymentName();
        String pubNamespaceName = gdaiModelDeploy.getPubNamespaceName();
        if (StringUtils.isNotBlank(pubDeploymentName) && StringUtils.isNotBlank(pubNamespaceName)) {
            // 释放节点资源
            releaseResource(gdaiModelDeploy, gdaiNodeInfoService, k8sClientOperator);
            ApiClient client = k8sInit2.getConnection();
            AppsV1Api api = new AppsV1Api(client);
            try {
                api.deleteNamespacedDeployment(pubDeploymentName, pubNamespaceName, null, null, 0, null, "", new V1DeleteOptions());
            } catch (ApiException e) {
                log.info("删除pod异常", e);
            }
        }
        return gdaiModelDeploy;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1Service
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为createDeploymentV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private GdaiModelDeploy createDeploymentV2(GdaiModelDeploy gdaiModelDeploy, V1Deployment deployment, K8sClientOperator k8sClientOperator) throws Exception {
    try {
        V1Deployment createResult = k8sClientOperator.createDeployment(deployment, gdaiModelDeploy.getPubNamespaceName());
        gdaiModelDeploy.setPubDeploymentName(createResult.getMetadata().getName());
        gdaiModelDeploy.setPubPodLabelSelector("app=" + createResult.getSpec().getSelector().getMatchLabels().get("app"));
    } catch (Exception e) {
        throw e;
    }
    return gdaiModelDeploy;
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Deployment
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为getPubUrl的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Map<String, String> getPubUrl(GdaiModelDeploy gdaiModelDeploy, Integer curNodePort, K8sInit2 k8sInit2) throws Exception {
    try {
        ApiClient client = k8sInit2.getConnection();
        log.info("getPubUrl client:" + client.getBasePath() + client.getJSON());
        CoreV1Api apiInstance = new CoreV1Api(client);
        V1PodList curV1PodList;
        try {
            curV1PodList = apiInstance.listNamespacedPod(gdaiModelDeploy.getPubNamespaceName(), null, null, null, null, gdaiModelDeploy.getPubPodLabelSelector(), null, null, null, null, null);
        } catch (Exception e) {
            log.info("获取pod列表异常", e);
            throw e;
        }
        // 目前约定只有一个pod
        if (curV1PodList == null) {
            return null;
        } else {
            List<V1Pod> v1PodList = curV1PodList.getItems();
            if (v1PodList == null || v1PodList.isEmpty()) {
                return null;
            } else {
                V1Pod curV1Pod = v1PodList.get(0);
                log.info("getPubUrl curV1Pod:" + curV1Pod.toString());
                String podName = curV1Pod.getMetadata().getName();
                String podLogs = apiInstance.readNamespacedPodLog(podName, gdaiModelDeploy.getPubNamespaceName(), null, null, null, null, null, null, null, null, null);
                log.info("getPubUrl podLogs:" + podLogs);
                //获取服务名
                String pubUrl = gdaiModelDeploy.getPubUrl();
                //根据标签查询对应pod获取对应node节点IP地址
                String podIP = curV1Pod.getStatus().getHostIP();
                //考虑同pod下多个服务的返回情况
                pubUrl = "http://" + podIP + ":" + curNodePort + "/" + pubUrl;
                String pubPodName = curV1Pod.getMetadata().getName();
                Map<String, String> map = new HashMap<>();
                map.put("pubUrl", pubUrl);
                map.put("pubPodName", pubPodName);
                return map;
            }
        }
    } catch (Exception ex) {
        log.error("deployment exception:", ex);
        throw ex;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
java.util.HashMap
java.util.List
java.util.Map
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为createServiceV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private GdaiModelDeploy createServiceV2(GdaiModelDeploy gdaiModelDeploy, V1Service service, K8sClientOperator k8sClientOperator) throws Exception {
    // 现有实现是只适配已知应用yaml的已有属性项，若新应用的yaml有新的属性项，按实际增加相应应的项。
    try {
        V1Service createResult = k8sClientOperator.createService(service, gdaiModelDeploy.getPubNamespaceName());
        gdaiModelDeploy.setPubNodePort(createResult.getSpec().getPorts().get(0).getNodePort());
        //gdaiDevModel.setContainerPort(service.getSpec().getPorts().get(0).getTargetPort());
        gdaiModelDeploy.setPubServicePort(createResult.getSpec().getPorts().get(0).getPort());
        gdaiModelDeploy.setPubServiceName(createResult.getMetadata().getName());
    } catch (Exception e) {
        throw e;
    }
    return gdaiModelDeploy;
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Service
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为checkPodCreated的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public boolean checkPodCreated(String namespace, String podLabelSelector, K8sInit2 k8sInit2) throws Exception {
    try {
        ApiClient client = k8sInit2.getConnection();
        log.info("checkPodCreated client:" + client.getBasePath() + client.getJSON());
        CoreV1Api apiInstance = new CoreV1Api(client);
        V1PodList curV1PodList;
        try {
            curV1PodList = apiInstance.listNamespacedPod(namespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
        } catch (Exception e) {
            throw e;
        }
        // 目前约定只有一个pod
        if (curV1PodList == null) {
            return false;
        } else {
            List<V1Pod> v1PodList = curV1PodList.getItems();
            if (v1PodList == null || v1PodList.isEmpty()) {
                return false;
            } else {
                V1Pod curV1Pod = v1PodList.get(0);
                log.info("checkPodCreated curV1Pod:" + curV1Pod.toString());
                log.info("checkPodCreated curV1Pod getStatus:" + curV1Pod.getStatus());
                if ("Running".equalsIgnoreCase(curV1Pod.getStatus().getPhase())) {
                    return true;
                } else {
                    return false;
                }
            }
        }
    } catch (Exception ex) {
        log.error("deployment exception:", ex);
        throw ex;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为buildCntrMsg的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildCntrMsg(String message, GdaiModelDeploy gdaiModelDeploy, K8sClientOperator k8sClientOperator) throws Exception {
    JSONObject object = new JSONObject();
    if (StringUtils.isNotEmpty(gdaiModelDeploy.getPubCntrMsg())) {
        object = JSON.parseObject(gdaiModelDeploy.getPubCntrMsg());
    }
    object.put("message", message);
    if (StringUtils.isEmpty(gdaiModelDeploy.getPubPodName())) {
        V1PodList curV1PodList = k8sClientOperator.listNamespacedPod(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector());
        if (curV1PodList != null && !curV1PodList.getItems().isEmpty()) {
            gdaiModelDeploy.setPubPodName(curV1PodList.getItems().get(0).getMetadata().getName());
        }
    }
    if (StringUtils.isNotEmpty(gdaiModelDeploy.getPubPodName())) {
        List<Event> events = k8sClientOperator.getEvents(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodName());
        if (events != null) {
            object.put("event", events);
        }
    }
    if (StringUtils.isNotEmpty(gdaiModelDeploy.getPubDeploymentName())) {
        ContainerState state = k8sClientOperator.getContainerState(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector());
        if (state != null) {
            object.put("state", state);
        }
    }
    gdaiModelDeploy.setPubCntrMsg(JSON.toJSONString(object));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为releaseResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private void releaseResource(GdaiModelDeploy gdaiModelDeploy, GdaiNodeInfoService gdaiNodeInfoService, K8sClientOperator k8sClientOperator) throws Exception {
    //再次查询部署容器运行状态
    Long devId = gdaiModelDeploy.getDeployId();
    V1PodList v1PodList = k8sClientOperator.listNamespacedPod(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector());
    if (v1PodList != null && v1PodList.getItems().size() > 0) {
        V1Pod v1Pod = v1PodList.getItems().get(0);
        String podName = v1Pod.getMetadata().getName();
        String phase = v1Pod.getStatus().getPhase();
        //            if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(phase) && "Running".equals(phase)) {
        //                //service创建成功，则扣除所占资源
        //                //查询该容器在那个节点上
        //                String nodeIp = v1Pod.getSpec().getNodeName();
        //                gdaiNodeInfoService.releaseNode(nodeIp, "deploy", gdaiModelDeploy.getCore(), gdaiModelDeploy.getMemorySize(), gdaiModelDeploy.getGpuSize());
        //            }
    }
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为applyResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private void applyResource(GdaiModelDeploy gdaiModelDeploy, GdaiNodeInfoService gdaiNodeInfoService, K8sClientOperator k8sClientOperator) throws Exception {
    //再次查询部署容器运行状态
    Long devId = gdaiModelDeploy.getDeployId();
    V1PodList v1PodList = k8sClientOperator.listNamespacedPod(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector());
    if (v1PodList != null && v1PodList.getItems().size() > 0) {
        V1Pod v1Pod = v1PodList.getItems().get(0);
        String podName = v1Pod.getMetadata().getName();
        String phase = v1Pod.getStatus().getPhase();
        if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(phase) && !"Running".equals(phase)) {
            gdaiModelDeploy.setStatus("S2E");
            gdaiModelDeploy.setDeployName(podName);
            //gdaiModelDeploy.setPubCntrMsg(phase);
        } else {
            //service创建成功，则扣除所占资源
            //查询该容器在那个节点上
            //                String nodeIp = v1Pod.getSpec().getNodeName();
            //                gdaiNodeInfoService.applyNode(nodeIp, "deploy", gdaiModelDeploy.getCore(), gdaiModelDeploy.getMemorySize(), gdaiModelDeploy.getGpuSize());
        }
    }
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingServiceImpl中有一个名为checkGdaiAutoTraining的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiAutoTraining checkGdaiAutoTraining(User user, Long autoTrainId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiAutoTraining gdaiAutoTraining = gdaiAutoTrainingMapper.selectById(autoTrainId);
    if (gdaiAutoTraining == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiAutoTraining.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiAutoTraining.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiAutoTraining.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiAutoTraining;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
org.springframework.stereotype.Service
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiProjectService gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiAutoTrainingSetVo gdaiAutoTrainingSetVo) {
    log.info("GdaiAutoTrainingSetServiceImpl.add params: {}", JSON.toJSONString(gdaiAutoTrainingSetVo));
    GdaiAutoTrainingSet gdaiAutoTrainingSet = new GdaiAutoTrainingSet();
    BeanUtils.copyProperties(gdaiAutoTrainingSetVo, gdaiAutoTrainingSet);
    Long projectId = gdaiAutoTrainingSetVo.getProjectId();
    Long autoManageId = gdaiAutoTrainingSetVo.getAutoManageId();
    String autoTrainType = gdaiAutoTrainingSetVo.getAutoTrainType();
    String type = gdaiAutoTrainingSetVo.getType();
    String trainName = gdaiAutoTrainingSetVo.getTrainName();
    Long creatorId = gdaiAutoTrainingSetVo.getCreatorId();
    String shareFlag = gdaiAutoTrainingSetVo.getShareFlag();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (autoManageId == null) {
        return RestResult.genFailResult("自训练管理ID不能为空");
    }
    if (StringUtils.isBlank(autoTrainType)) {
        return RestResult.genFailResult("自训练任务类别不能为空");
    }
    if (StringUtils.isBlank(type)) {
        return RestResult.genFailResult("任务类型不能为空");
    }
    if (StringUtils.isBlank(trainName)) {
        return RestResult.genFailResult("任务名称不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    try {
        Date curDate = new Date();
        gdaiAutoTrainingSet.setCreateTime(curDate);
        gdaiAutoTrainingSet.setModifyTime(curDate);
        gdaiAutoTrainingSetMapper.insert(gdaiAutoTrainingSet);
        Long trainSetId = gdaiAutoTrainingSet.getTrainSetId();
        return RestResult.genSuccessResult(trainSetId);
    } catch (Exception e) {
        log.info("创建任务组异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("创建任务组异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为addTraining的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addTraining(GdaiAutoTrainingVo gdaiAutoTrainingVo) {
    log.info("GdaiAutoTrainingSetServiceImpl.addTraining params: {}", JSON.toJSONString(gdaiAutoTrainingVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    GdaiAutoTraining gdaiAutoTraining = new GdaiAutoTraining();
    BeanUtils.copyProperties(gdaiAutoTrainingVo, gdaiAutoTraining);
    Long projectId = gdaiAutoTrainingVo.getProjectId();
    Long trainSetId = gdaiAutoTrainingVo.getTrainSetId();
    String datasetSource = gdaiAutoTrainingVo.getDatasetSource();
    Long autoManageId = gdaiAutoTrainingVo.getAutoManageId();
    String autoTrainType = gdaiAutoTrainingVo.getAutoTrainType();
    Long creatorId = gdaiAutoTrainingVo.getCreatorId();
    String shareFlag = gdaiAutoTrainingVo.getShareFlag();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (trainSetId == null) {
        return RestResult.genFailResult("自训练组ID不能为空");
    }
    if (autoManageId == null) {
        return RestResult.genFailResult("自训练管理ID不能为空");
    }
    if (StringUtils.isBlank(autoTrainType)) {
        return RestResult.genFailResult("自训练任务类别不能为空");
    }
    if (StringUtils.isBlank(datasetSource)) {
        return RestResult.genFailResult("数据集来源不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    Map<String, Object> map = new HashMap();
    try {
        Date curDate = new Date();
        //根据auto_manage_id，auto_train_type，train_set_id，creator_id查询当前最大版本号，若没有则默认版本为1，如果有则自增1
        int maxVersion = gdaiAutoTrainingMapper.getMaxVersion(autoManageId, autoTrainType, trainSetId, creatorId);
        gdaiAutoTraining.setTrainVersion((long) (maxVersion + 1));
        gdaiAutoTraining.setCreatorId(creatorId);
        gdaiAutoTraining.setCreateTime(curDate);
        gdaiAutoTraining.setModifyTime(curDate);
        //解决字段非空约束,默认赋值为空
        gdaiAutoTraining.setTrainYmlContent("");
        gdaiAutoTraining.setCommandAndArgs("");
        gdaiAutoTraining.setCntrMsg("");
        gdaiAutoTrainingMapper.insert(gdaiAutoTraining);
        Long autoTrainId = gdaiAutoTraining.getAutoTrainId();
        //拼装基础路径
        //            String basePath = cephUploadPath + autogluon + projectId + "/" + trainSetId + "/" + autoTrainId;
        String basePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.AUTOGLUON + "/" + trainSetId + "/" + autoTrainId;
        //拼装模型保存目录
        String modelSavePath = basePath + "/out/";
        if ("1".equals(datasetSource)) {
            //平台数据集
            gdaiAutoTraining.setModelSavePath(modelSavePath);
            gdaiAutoTrainingMapper.updateById(gdaiAutoTraining);
            map.put("trainSetId", trainSetId);
            map.put("autoTrainId", autoTrainId);
            map.put("modelSavePath", modelSavePath);
        } else if ("2".equals(datasetSource)) {
            //数据集为本地上传数据集
            String datasetTrainPath = basePath + "/datasets/trainDataset/";
            String datasetTestPath = basePath + "/datasets/testDataset/";
            gdaiAutoTraining.setDatasetTrainPath(datasetTrainPath);
            gdaiAutoTraining.setDatasetTestPath(datasetTestPath);
            gdaiAutoTraining.setModelSavePath(modelSavePath);
            gdaiAutoTrainingMapper.updateById(gdaiAutoTraining);
            map.put("trainSetId", trainSetId);
            map.put("autoTrainId", autoTrainId);
            map.put("datasetTrainPath", datasetTrainPath);
            map.put("datasetTestPath", datasetTestPath);
            map.put("modelSavePath", modelSavePath);
        } else {
            return RestResult.genFailResult("数据来源类型错误");
        }
        return RestResult.genSuccessResult(map);
    } catch (Exception e) {
        log.info("创建任务异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("创建任务异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.HashMap
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * 自训练存储目录
 */
@Value("${cephUpload.autogluon}")
private String autogluon;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为upload的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult upload(GdaiAutoTrainingSetVo gdaiAutoTrainingSetVo) {
    log.info("GdaiAutoTrainingSetServiceImpl.upload");
    MultipartFile file = gdaiAutoTrainingSetVo.getFile();
    if (file == null) {
        return RestResult.genFailResult("上传文件不能为空");
    }
    String datasetPath = gdaiAutoTrainingSetVo.getDatasetPath();
    if (StringUtils.isBlank(datasetPath)) {
        return RestResult.genFailResult("上传路径不能为空");
    }
    try {
        FileUtil.createDir(datasetPath);
        String originalFilename = file.getOriginalFilename();
        //上传文件到指定目录
        File path = FileUtils.getFile(datasetPath + originalFilename);
        file.transferTo(path);
        //将上传的zip包进行解压
        String extension = FilenameUtils.getExtension(originalFilename);
        if ("zip".equalsIgnoreCase(extension)) {
            String srcZipPath = datasetPath + "/" + originalFilename;
            File zipPath = FileUtils.getFile(srcZipPath);
            List<String> unZipPath = ZipUtil.unZip(zipPath, datasetPath);
            //解压完毕删除zip文件
            if (zipPath != null) {
                if (zipPath.exists()) {
                    zipPath.delete();
                }
            }
        }
        return RestResult.genSuccessResult(datasetPath);
    } catch (Exception e) {
        log.info("上传异常", e);
        return RestResult.genFailResult("上传异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
org.apache.commons.io.FileUtils
org.apache.commons.io.FilenameUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.List
java.util.Set
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为submit的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult submit(GdaiAutoTrainingSetVo gdaiAutoTrainingSetVo) {
    log.info("GdaiAutoTrainingSetServiceImpl.submit params: {}", JSON.toJSONString(gdaiAutoTrainingSetVo));
    GdaiAutoTraining gdaiAutoTraining = new GdaiAutoTraining();
    BeanUtils.copyProperties(gdaiAutoTrainingSetVo, gdaiAutoTraining);
    Long projectId = gdaiAutoTrainingSetVo.getProjectId();
    Long autoTrainId = gdaiAutoTrainingSetVo.getAutoTrainId();
    Long trainSetId = gdaiAutoTrainingSetVo.getTrainSetId();
    Long autoManageId = gdaiAutoTrainingSetVo.getAutoManageId();
    String autoTrainType = gdaiAutoTrainingSetVo.getAutoTrainType();
    String datasetTrainPath = gdaiAutoTrainingSetVo.getDatasetTrainPath();
    String datasetTestPath = gdaiAutoTrainingSetVo.getDatasetTestPath();
    String modelSavePath = gdaiAutoTrainingSetVo.getModelSavePath();
    String processUnitType = gdaiAutoTrainingSetVo.getProcessUnitType();
    String core = gdaiAutoTrainingSetVo.getCore();
    String memorySize = gdaiAutoTrainingSetVo.getMemorySize();
    String gpuSize = gdaiAutoTrainingSetVo.getGpuSize();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (trainSetId == null) {
        return RestResult.genFailResult("自训练组ID不能为空");
    }
    if (autoManageId == null) {
        return RestResult.genFailResult("自训练管理ID不能为空");
    }
    if (StringUtils.isBlank(autoTrainType)) {
        return RestResult.genFailResult("自训练任务类别不能为空");
    }
    if (StringUtils.isBlank(datasetTrainPath)) {
        return RestResult.genFailResult("训练集路径不能为空");
    }
    if (StringUtils.isBlank(datasetTestPath)) {
        return RestResult.genFailResult("验证集路径不能为空");
    }
    if (StringUtils.isBlank(modelSavePath)) {
        return RestResult.genFailResult("模型结果保存路径不能为空");
    }
    if (StringUtils.isBlank(core)) {
        return RestResult.genFailResult("核心数不能为空");
    }
    if (StringUtils.isBlank(memorySize)) {
        return RestResult.genFailResult("内存大小不能为空");
    }
    if (StringUtils.isBlank(gpuSize)) {
        return RestResult.genFailResult("GPU大小不能为空");
    }
    try {
        GdaiAutoManage gdaiAutoManage = gdaiAutoManageMapper.selectById(autoManageId);
        if (gdaiAutoManage == null) {
            return RestResult.genFailResult("自训练管理信息为空");
        }
        if ("1".equals(autoTrainType)) {
            String trainYmlContent = gdaiAutoManage.getYmlContent();
            if (StringUtils.isBlank(trainYmlContent)) {
                return RestResult.genFailResult("训练模板不能为空");
            }
            gdaiAutoTraining.setTrainYmlContent(trainYmlContent);
        } else if ("2".equals(autoTrainType)) {
            String reasoningYmlContent = gdaiAutoManage.getReasoningYmlContent();
            if (StringUtils.isBlank(reasoningYmlContent)) {
                return RestResult.genFailResult("推理模板不能为空");
            }
            gdaiAutoTraining.setTrainYmlContent(reasoningYmlContent);
        }
        gdaiAutoTraining.setAutoTrainType(autoTrainType);
        //根据项目ID查询该项目当前资源占用情况
        GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
        if (gdaiProject == null) {
            return RestResult.genFailResult("该项目不存在");
        }
        Long projectCoreNumber = gdaiProject.getProjectCoreNumber();
        Long projectCpuSize = gdaiProject.getProjectCpuSize();
        Long projectGpuSize = gdaiProject.getProjectGpuSize();
        Long usedCoreNumber = gdaiProject.getUsedCoreNumber();
        Long usedCpuSize = gdaiProject.getUsedCpuSize();
        Long usedGpuSize = gdaiProject.getUsedGpuSize();
        //计算项目当前可用资源
        Long freeCoreNumber = projectCoreNumber - usedCoreNumber;
        Long freeCpuSize = projectCpuSize - usedCpuSize;
        Long freeGpuSize = projectGpuSize - usedGpuSize;
        //将用户自定义所需资源与可用资源进行对比
        long applyCore = Long.parseLong(core);
        if (applyCore > freeCoreNumber) {
            return RestResult.genFailResult("所需core超出项目总core");
        }
        String[] ms = memorySize.split("G");
        long applyMemorySize = Long.parseLong(ms[0]) * 1024;
        if (applyMemorySize > freeCpuSize) {
            return RestResult.genFailResult("所需cpu内存大小超出项目总内存大小");
        }
        long applyGpuMemorySize = (Long.parseLong(gpuSize) / 1000) * 1024;
        if (applyGpuMemorySize > freeGpuSize) {
            return RestResult.genFailResult("所需gpu大小超出项目总显存大小");
        }
        //算力大小默认设置为50%
        gdaiAutoTraining.setComputingPower("50");
        gdaiAutoTraining.setStatus("Pending");
        String modelOut = modelSavePath + "/model_out/";
        FileUtil.createDir(modelOut);
        if ("1".equals(autoTrainType)) {
            //训练任务
            String evalOut = modelSavePath + "/eval_out/";
            FileUtil.createDir(evalOut);
        } else if ("2".equals(autoTrainType)) {
            //预测任务
            String testOut = modelSavePath + "/test_out/";
            FileUtil.createDir(testOut);
        }
        gdaiAutoTraining.setProcessUnitType(processUnitType);
        gdaiAutoTraining.setCore(core);
        gdaiAutoTraining.setMemorySize(memorySize);
        //这里默认使用1张卡
        gdaiAutoTraining.setCardNumber(number);
        gdaiAutoTraining.setGpuSize(gpuSize);
        //设置命名空间，按项目划分 gdai-projectId
        gdaiAutoTraining.setNameSpace(GdaiConstant.NAMESPACE_PREFIX + projectId);
        gdaiAutoTrainingMapper.updateById(gdaiAutoTraining);
        //另起线程创建job训练任务
        GdaiAutoTrainingServiceImpl gdaiAutoTrainingServiceImpl = new GdaiAutoTrainingServiceImpl();
        //            uploadThreadPool.execute(new GdaiAutoTrainingServiceImpl.StartTrainJob(k8sClientOperator, gdaiAutoTrainingMapper, gdaiClusterInfoMapper, gdaiNodeInfoMapper, gdaiProjectMapper, k8sInit2, gdaiAutoTrainingServiceImpl, gdaiAutoTraining, gdaiNodeInfoService, gdaiProjectService, projectId));
        gdaiAutoTrainingAsyncTask.startAutoTraining(gdaiAutoTraining);
    } catch (Exception e) {
        log.info("新增训练模型记录异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult(autoTrainId);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private K8sInit2 k8sInit2;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
@Resource
private GdaiAutoTrainingAsyncTask gdaiAutoTrainingAsyncTask;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiAutoTrainingSet gdaiAutoTrainingSet) throws TrainginCenterException {
    log.info("GdaiAutoTrainingSetServiceImpl.updateShareFlag params: [{}]", JSON.toJSONString(gdaiAutoTrainingSet));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //        Long userId = user.getId();
    Long trainSetId = gdaiAutoTrainingSet.getTrainSetId();
    String shareFlag = gdaiAutoTrainingSet.getShareFlag();
    if (trainSetId == null) {
        return RestResult.genFailResult("智能训练组ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    checkGdaiAutoTrainingSet(user, trainSetId, false);
    //        GdaiAutoTrainingSet autoTrainingSet = gdaiAutoTrainingSetMapper.selectById(trainSetId);
    //        if (autoTrainingSet == null) {
    //            return RestResult.genFailResult("该记录不存在");
    //        }
    //        //修改之前判断当前修改人是否和创建人一致（该条记录的创建者才有修改权限）
    //        Long creatorId = autoTrainingSet.getCreatorId();
    //        if (!creatorId.equals(userId)) {
    //            return RestResult.genFailResult("非创建者不能修改该状态");
    //        }
    GdaiAutoTrainingSet trainingSet = new GdaiAutoTrainingSet();
    trainingSet.setTrainSetId(trainSetId);
    trainingSet.setShareFlag(shareFlag);
    trainingSet.setModifyTime(new Date());
    gdaiAutoTrainingSetMapper.updateById(trainingSet);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiAutoTrainingSet gdaiAutoTrainingSet) {
    log.info("GdaiAutoTrainingSetServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiAutoTrainingSet));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long trainSetId = gdaiAutoTrainingSet.getTrainSetId();
    if (trainSetId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    String status = null;
    GdaiAutoTrainingSet autoTrainingSet;
    try {
        //删除之前检查是否存在
        //修复水平越权问题
        autoTrainingSet = checkGdaiAutoTrainingSet(user, trainSetId, false);
        //            autoTrainingSet = gdaiAutoTrainingSetMapper.selectById(trainSetId);
        if (autoTrainingSet != null) {
            //                //判断用户是否是超级管理员,如果是超管则直接删除,如果不是超管,删除之前判断当前用户是否和创建人一致（该条记录的创建者才有删除权限）
            //                Boolean superAdminRole = CommonTools.checkDeletePermission(request, userId, autoTrainingSet.getCreatorId());
            //                if (!superAdminRole) {
            //                    return RestResult.genFailResult("非创建者不能删除该记录");
            //                }
            List<GdaiAutoTraining> list = gdaiAutoTrainingMapper.selectList(new EntityWrapper<GdaiAutoTraining>().eq("train_set_id", trainSetId));
            if (list != null && list.size() > 0) {
                for (GdaiAutoTraining autoTraining : list) {
                    Long autoTrainId = autoTraining.getAutoTrainId();
                    String jobName = autoTraining.getJobName();
                    String podName = autoTraining.getPodName();
                    String namespace = autoTraining.getNameSpace();
                    status = autoTraining.getStatus();
                    if (StringUtils.isNotBlank(jobName) && StringUtils.isNotBlank(namespace)) {
                        //删除job
                        ApiClient client = k8sInit2.getConnection();
                        BatchV1Api appsInstance = new BatchV1Api(client);
                        V1JobList v1JobList = appsInstance.listNamespacedJob(namespace, null, null, null, null, null, null, null, null, null, null);
                        List<V1Job> items = v1JobList.getItems();
                        for (V1Job v1Job : items) {
                            String name = v1Job.getMetadata().getName();
                            if (jobName.equals(name)) {
                                appsInstance.deleteNamespacedJob(jobName, namespace, null, null, 0, null, "", new V1DeleteOptions());
                                break;
                            }
                        }
                    }
                    if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(namespace)) {
                        //删除pod
                        ApiClient client = k8sInit2.getConnection();
                        CoreV1Api api = new CoreV1Api(client);
                        V1PodList v1PodList = api.listNamespacedPod(namespace, null, null, null, null, null, null, null, null, null, null);
                        List<V1Pod> items = v1PodList.getItems();
                        for (V1Pod v1Pod : items) {
                            String name = v1Pod.getMetadata().getName();
                            if (podName.equals(name)) {
                                api.deleteNamespacedPod(podName, namespace, null, null, 0, null, "", new V1DeleteOptions());
                                break;
                            }
                        }
                    }
                    //根据ID删除
                    gdaiAutoTrainingMapper.deleteById(autoTrainId);
                    //刪除对应文件夹
                    Long projectId = autoTraining.getProjectId();
                    //                        String filePath = cephUploadPath + autogluon + projectId + "/" + autoTrainId;
                    String filePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.AUTOGLUON + "/" + trainSetId + "/" + autoTrainId;
                    FileUtil.deleteFile(FileUtils.getFile(filePath));
                }
            }
            //删除组记录
            gdaiAutoTrainingSetMapper.deleteById(trainSetId);
            //刪除对应文件夹
            Long projectId = autoTrainingSet.getProjectId();
            //                String filePath = cephUploadPath + autogluon + projectId + "/" + trainSetId;
            String filePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.AUTOGLUON + "/" + trainSetId;
            FileUtil.deleteFile(FileUtils.getFile(filePath));
            return RestResult.genSuccessResult("删除成功");
        }
    } catch (Exception e) {
        log.info("删除训练模型记录异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    gdaiAutoTrainingSetMapper.updateById(new GdaiAutoTrainingSet(trainSetId, status, new Date()));
    return RestResult.genFailResult("删除异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Date
java.util.List
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * 自训练存储目录
 */
@Value("${cephUpload.autogluon}")
private String autogluon;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为queryList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryList(GdaiAutoTrainingSetVo gdaiAutoTrainingSetVo) {
    log.info("GdaiAutoTrainingSetServiceImpl.queryList params: [{}]}", JSON.toJSONString(gdaiAutoTrainingSetVo));
    Long projectId = gdaiAutoTrainingSetVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String autoTrainType = gdaiAutoTrainingSetVo.getAutoTrainType();
    if (StringUtils.isBlank(autoTrainType)) {
        return RestResult.genFailResult("任务类别不能为空");
    }
    Long autoManageId = gdaiAutoTrainingSetVo.getAutoManageId();
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    //        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(request);
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员创建的任务
        UiPage<GdaiAutoTrainingSetVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiAutoTrainingSetVo> list = new ArrayList<>();
        Page<GdaiAutoTrainingSet> gdaiAutoTrainingSetPage = gdaiAutoTrainingSetService.selectPage(new Page<>(gdaiAutoTrainingSetVo.getPageNumber(), gdaiAutoTrainingSetVo.getPageCount()), new EntityWrapper<GdaiAutoTrainingSet>().eq("project_id", projectId).eq("auto_train_type", autoTrainType).eq(autoManageId != null, "auto_manage_id", autoManageId).orderDesc(desc));
        if (gdaiAutoTrainingSetPage != null && gdaiAutoTrainingSetPage.getRecords().size() > 0) {
            List<GdaiAutoTrainingSet> records = gdaiAutoTrainingSetPage.getRecords();
            for (GdaiAutoTrainingSet autoTrainingSet : records) {
                Long trainSetId = autoTrainingSet.getTrainSetId();
                gdaiAutoTrainingSetVo = new GdaiAutoTrainingSetVo();
                BeanUtils.copyProperties(autoTrainingSet, gdaiAutoTrainingSetVo);
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, autoTrainingSet.getCreatorId());
                if (userInfo != null) {
                    gdaiAutoTrainingSetVo.setCreatorName(userInfo.getUsername());
                }
                autoManageId = autoTrainingSet.getAutoManageId();
                //查询当前自训练组下拥有的版本数
                int versionCount = gdaiAutoTrainingMapper.queryVersionCount(trainSetId);
                gdaiAutoTrainingSetVo.setVersionCount(versionCount);
                //查询dataType
                GdaiAutoManage autoManage = gdaiAutoManageMapper.selectById(autoManageId);
                if (autoManage != null) {
                    gdaiAutoTrainingSetVo.setDataType(autoManage.getDataType());
                }
                list.add(gdaiAutoTrainingSetVo);
            }
            uiPage.setTotal(gdaiAutoTrainingSetPage.getTotal());
            uiPage.setPageSize(gdaiAutoTrainingSetPage.getSize());
            uiPage.setPages(gdaiAutoTrainingSetPage.getPages());
            uiPage.setPageNum(gdaiAutoTrainingSetPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    } else {
        UiPage<GdaiAutoTrainingSetVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiAutoTrainingSetVo> list = new ArrayList<>();
        Page<GdaiAutoTrainingSet> gdaiAutoTrainingSetPage = gdaiAutoTrainingSetService.selectPage(new Page<>(gdaiAutoTrainingSetVo.getPageNumber(), gdaiAutoTrainingSetVo.getPageCount()), new EntityWrapper<GdaiAutoTrainingSet>().eq("project_id", projectId).eq("auto_train_type", autoTrainType).eq(autoManageId != null, "auto_manage_id", autoManageId).andNew().eq("share_flag", "1").or().eq("creator_id", userId).orderDesc(desc));
        if (gdaiAutoTrainingSetPage != null && gdaiAutoTrainingSetPage.getRecords().size() > 0) {
            List<GdaiAutoTrainingSet> records = gdaiAutoTrainingSetPage.getRecords();
            for (GdaiAutoTrainingSet autoTrainingSet : records) {
                Long trainSetId = autoTrainingSet.getTrainSetId();
                gdaiAutoTrainingSetVo = new GdaiAutoTrainingSetVo();
                BeanUtils.copyProperties(autoTrainingSet, gdaiAutoTrainingSetVo);
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, autoTrainingSet.getCreatorId());
                if (userInfo != null) {
                    gdaiAutoTrainingSetVo.setCreatorName(userInfo.getUsername());
                }
                autoManageId = autoTrainingSet.getAutoManageId();
                //查询当前自训练组下拥有的版本数
                int versionCount = gdaiAutoTrainingMapper.queryVersionCount2(trainSetId, userId);
                gdaiAutoTrainingSetVo.setVersionCount(versionCount);
                //查询dataType
                GdaiAutoManage autoManage = gdaiAutoManageMapper.selectById(autoManageId);
                if (autoManage != null) {
                    gdaiAutoTrainingSetVo.setDataType(autoManage.getDataType());
                }
                list.add(gdaiAutoTrainingSetVo);
            }
            uiPage.setTotal(gdaiAutoTrainingSetPage.getTotal());
            uiPage.setPageSize(gdaiAutoTrainingSetPage.getSize());
            uiPage.setPages(gdaiAutoTrainingSetPage.getPages());
            uiPage.setPageNum(gdaiAutoTrainingSetPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
com.eshore.gdai.trainingcenter.vo.GdaiAutoTrainingSetVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingSetService gdaiAutoTrainingSetService;
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Resource
private UserClient userClient;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为queryBySetId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryBySetId(GdaiAutoTrainingSetVo gdaiAutoTrainingSetVo) {
    log.info("GdaiAutoTrainingSetServiceImpl.queryById params: [{}]", JSON.toJSONString(gdaiAutoTrainingSetVo));
    Long trainSetId = gdaiAutoTrainingSetVo.getTrainSetId();
    if (trainSetId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        GdaiAutoTrainingSet gdaiAutoTrainingSet = checkGdaiAutoTrainingSet(user, trainSetId, true);
        //            GdaiAutoTrainingSet gdaiAutoTrainingSet = gdaiAutoTrainingSetMapper.selectById(trainSetId);
        //            if (gdaiAutoTrainingSet == null) {
        //                return RestResult.genFailResult("未查询到该训练组任务");
        //            }
        BeanUtils.copyProperties(gdaiAutoTrainingSet, gdaiAutoTrainingSetVo);
        //查询dataType
        GdaiAutoManage autoManage = gdaiAutoManageMapper.selectById(gdaiAutoTrainingSet.getAutoManageId());
        if (autoManage != null) {
            gdaiAutoTrainingSetVo.setDataType(autoManage.getDataType());
        }
        return RestResult.genSuccessResult(gdaiAutoTrainingSetVo);
    } catch (Exception e) {
        log.info("查询异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoManage
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.service.GdaiAutoTrainingSetService
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Resource
private GdaiAutoManageMapper gdaiAutoManageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiAutoTrainingSetServiceImpl中有一个名为checkGdaiAutoTrainingSet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiAutoTrainingSet checkGdaiAutoTrainingSet(User user, Long trainSetId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiAutoTrainingSet gdaiAutoTrainingSet = gdaiAutoTrainingSetMapper.selectById(trainSetId);
    if (gdaiAutoTrainingSet == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiAutoTrainingSet.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiAutoTrainingSet.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiAutoTrainingSet.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiAutoTrainingSet;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
org.springframework.stereotype.Service
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Resource
private GdaiProjectService gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiClusterInfo gdaiClusterInfo) {
    log.info("GdaiClusterInfoServiceImpl.add params: [{}]", JSON.toJSONString(gdaiClusterInfo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    String clusterName = gdaiClusterInfo.getClusterName();
    Long clusterCoreNumber = gdaiClusterInfo.getClusterCoreNumber();
    Long clusterCpuSize = gdaiClusterInfo.getClusterCpuSize();
    Long clusterGpuSize = gdaiClusterInfo.getClusterGpuSize();
    Long clusterDiskSize = gdaiClusterInfo.getClusterDiskSize();
    if (StringUtils.isBlank(clusterName)) {
        return RestResult.genFailResult("集群名称不能为空");
    }
    if (clusterCoreNumber == null) {
        return RestResult.genFailResult("集群总核数不能为空");
    }
    if (clusterCpuSize == null) {
        return RestResult.genFailResult("集群总CPU大小不能为空");
    }
    if (clusterGpuSize == null) {
        return RestResult.genFailResult("集群总GPU大小不能为空");
    }
    if (clusterDiskSize == null) {
        return RestResult.genFailResult("集群总磁盘大小不能为空");
    }
    try {
        //查询是否存在同名集群
        GdaiClusterInfo clusterInfo = gdaiClusterInfoMapper.selectOne(new GdaiClusterInfo(clusterName));
        if (clusterInfo != null) {
            return RestResult.genFailResult("已存在同名集群");
        }
        Date curDate = new Date();
        gdaiClusterInfo.setCreatorId(userId);
        gdaiClusterInfo.setCreateTime(curDate);
        gdaiClusterInfo.setModifyTime(curDate);
        gdaiClusterInfoMapper.insert(gdaiClusterInfo);
    } catch (Exception e) {
        log.info("新增集群信息异常", e);
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiClusterInfo gdaiClusterInfo) throws TrainginCenterException {
    log.info("GdaiClusterInfoServiceImpl.update params: [{}]", JSON.toJSONString(gdaiClusterInfo));
    Long clusterId = gdaiClusterInfo.getClusterId();
    if (clusterId == null) {
        return RestResult.genFailResult("集群ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiClusterInfo clusterInfo = checkGdaiClusterInfo(user, clusterId);
    try {
        BeanUtils.copyProperties(gdaiClusterInfo, clusterInfo);
        Date curDate = new Date();
        clusterInfo.setModifyTime(curDate);
        clusterInfo.setModifierId(user.getId());
        gdaiClusterInfoMapper.updateById(clusterInfo);
    } catch (Exception e) {
        log.info("修改集群信息异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
cn.hutool.core.bean.BeanUtil
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiClusterInfo gdaiClusterInfo) throws TrainginCenterException {
    log.info("GdaiClusterInfoServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiClusterInfo));
    Long clusterId = gdaiClusterInfo.getClusterId();
    if (clusterId == null) {
        return RestResult.genFailResult("集群ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiClusterInfo clusterInfo = checkGdaiClusterInfo(user, clusterId);
    try {
        //            //检查该集群是否存在
        //            GdaiClusterInfo clusterInfo = gdaiClusterInfoMapper.selectById(clusterId);
        //            if (clusterInfo == null) {
        //                return RestResult.genFailResult("该集群不存在");
        //            }
        //检查该集群下是否关联节点信息
        List<GdaiNodeInfo> clusterList = gdaiNodeInfoMapper.selectList(new EntityWrapper<GdaiNodeInfo>().eq("cluster_id", clusterId));
        if (clusterList != null && clusterList.size() > 0) {
            return RestResult.genFailResult("该集群有关联节点信息，请先删除其节点信息");
        }
        gdaiClusterInfoMapper.deleteById(clusterId);
    } catch (Exception e) {
        log.info("删除集群信息异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为queryClusterFreeInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryClusterFreeInfo(GdaiClusterInfoVo gdaiClusterInfoVo) {
    log.info("GdaiClusterInfoServiceImpl.queryClusterFreeInfo params: [{}]", JSON.toJSONString(gdaiClusterInfoVo));
    List<GdaiClusterInfoVo> list = new ArrayList<>();
    try {
        List<GdaiClusterInfo> gdaiClusterInfos = gdaiClusterInfoMapper.selectList(new EntityWrapper<>());
        //目前按一个集群处理
        if (gdaiClusterInfos != null && gdaiClusterInfos.size() > 0) {
            for (GdaiClusterInfo clusterInfo : gdaiClusterInfos) {
                Long clusterCoreNumber = clusterInfo.getClusterCoreNumber();
                Long clusterCpuSize = clusterInfo.getClusterCpuSize();
                Long clusterGpuSize = clusterInfo.getClusterGpuSize();
                Long clusterDiskSize = clusterInfo.getClusterDiskSize();
                Long usedCoreNumber = clusterInfo.getUsedCoreNumber();
                Long usedCpuSize = clusterInfo.getUsedCpuSize();
                Long usedGpuSize = clusterInfo.getUsedGpuSize();
                Long usedDiskSize = clusterInfo.getUsedDiskSize();
                //计算空闲的资源大小
                Long freeCoreNumber = clusterCoreNumber - usedCoreNumber;
                Long freeCpuSize = clusterCpuSize - usedCpuSize;
                Long freeGpuSize = clusterGpuSize - usedGpuSize;
                Long freeDiskSize = clusterDiskSize - usedDiskSize;
                GdaiClusterInfoVo clusterInfoVo = new GdaiClusterInfoVo();
                BeanUtils.copyProperties(clusterInfo, clusterInfoVo);
                clusterInfoVo.setFreeCoreNumber(freeCoreNumber);
                clusterInfoVo.setFreeCpuSize(freeCpuSize);
                clusterInfoVo.setFreeGpuSize(freeGpuSize);
                clusterInfoVo.setFreeDiskSize(freeDiskSize);
                list.add(clusterInfoVo);
            }
        }
    } catch (Exception e) {
        log.info("查询集群信息异常", e);
        return RestResult.genFailResult("查询集群信息异常");
    }
    return RestResult.genSuccessResult(list);
}
### 类导入的包
cn.hutool.core.bean.BeanUtil
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
com.eshore.gdai.trainingcenter.vo.GdaiClusterInfoVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为queryClusterList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryClusterList(GdaiClusterInfoVo gdaiClusterInfoVo) {
    log.info("GdaiClusterInfoServiceImpl.queryClusterList params: [{}]", JSON.toJSONString(gdaiClusterInfoVo));
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    List<GdaiClusterInfoVo> list = new ArrayList<>();
    UiPage<GdaiClusterInfoVo> uiPage = new UiPage<>();
    try {
        Page<GdaiClusterInfo> gdaiClusterInfoPage = gdaiClusterInfoService.selectPage(new Page<>(gdaiClusterInfoVo.getPageNumber(), gdaiClusterInfoVo.getPageCount()), new EntityWrapper<GdaiClusterInfo>().like(StringUtils.isNotBlank(gdaiClusterInfoVo.getClusterName()), "cluster_name", gdaiClusterInfoVo.getClusterName()).orderDesc(desc));
        if (gdaiClusterInfoPage != null && gdaiClusterInfoPage.getRecords().size() > 0) {
            List<GdaiClusterInfo> records = gdaiClusterInfoPage.getRecords();
            for (GdaiClusterInfo gdaiClusterInfo : records) {
                gdaiClusterInfoVo = new GdaiClusterInfoVo();
                BeanUtils.copyProperties(gdaiClusterInfo, gdaiClusterInfoVo);
                list.add(gdaiClusterInfoVo);
            }
            uiPage.setTotal(gdaiClusterInfoPage.getTotal());
            uiPage.setPageSize(gdaiClusterInfoPage.getSize());
            uiPage.setPages(gdaiClusterInfoPage.getPages());
            uiPage.setPageNum(gdaiClusterInfoPage.getCurrent());
            uiPage.setList(list);
        }
    } catch (Exception e) {
        log.info("查询集群列表异常", e);
        return RestResult.genFailResult("查询集群列表异常");
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
cn.hutool.core.bean.BeanUtil
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
com.eshore.gdai.trainingcenter.vo.GdaiClusterInfoVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiClusterInfoService gdaiClusterInfoService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为queryClusterAllRes的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryClusterAllRes(GdaiClusterInfoVo gdaiClusterInfoVo) {
    log.info("GdaiClusterInfoServiceImpl.queryClusterAllRes params: [{}]", JSON.toJSONString(gdaiClusterInfoVo));
    try {
        Long allClusterCoreNumber = gdaiClusterInfoMapper.getAllClusterCoreNumber();
        Long allClusterCpuSize = gdaiClusterInfoMapper.getAllClusterCpuSize();
        Long allClusterGpuSize = gdaiClusterInfoMapper.getAllClusterGpuSize();
        Long allClusterDiskSize = gdaiClusterInfoMapper.getAllClusterDiskSize();
        Long allUsedCoreNumber = gdaiClusterInfoMapper.getAllUsedCoreNumber();
        Long allUsedCpuSize = gdaiClusterInfoMapper.getAllUsedCpuSize();
        Long allUsedGpuSize = gdaiClusterInfoMapper.getAllUsedGpuSize();
        Long allUsedDiskSize = gdaiClusterInfoMapper.getAllUsedDiskSize();
        Long allDevUsedCoreNumber = gdaiClusterInfoMapper.getAllDevUsedCoreNumber();
        Long allDevUsedCpuSize = gdaiClusterInfoMapper.getAllDevUsedCpuSize();
        Long allDevUsedGpuSize = gdaiClusterInfoMapper.getAllDevUsedGpuSize();
        Long allDevUsedDiskSize = gdaiClusterInfoMapper.getAllDevUsedDiskSize();
        Long allTrainUsedCoreNumber = gdaiClusterInfoMapper.getAllTrainUsedCoreNumber();
        Long allTrainUsedCpuSize = gdaiClusterInfoMapper.getAllTrainUsedCpuSize();
        Long allTrainUsedGpuSize = gdaiClusterInfoMapper.getAllTrainUsedGpuSize();
        Long allTrainUsedDiskSize = gdaiClusterInfoMapper.getAllTrainUsedDiskSize();
        Long allDeployUsedCoreNumber = gdaiClusterInfoMapper.getAllDeployUsedCoreNumber();
        Long allDeployUsedCpuSize = gdaiClusterInfoMapper.getAllDeployUsedCpuSize();
        Long allDeployUsedGpuSize = gdaiClusterInfoMapper.getAllDeployUsedGpuSize();
        Long allDeployUsedDiskSize = gdaiClusterInfoMapper.getAllDeployUsedDiskSize();
        gdaiClusterInfoVo.setAllClusterCoreNumber(allClusterCoreNumber);
        gdaiClusterInfoVo.setAllClusterCpuSize(allClusterCpuSize);
        gdaiClusterInfoVo.setAllClusterGpuSize(allClusterGpuSize);
        gdaiClusterInfoVo.setAllClusterDiskSize(allClusterDiskSize);
        gdaiClusterInfoVo.setAllUsedCoreNumber(allUsedCoreNumber);
        gdaiClusterInfoVo.setAllUsedCpuSize(allUsedCpuSize);
        gdaiClusterInfoVo.setAllUsedGpuSize(allUsedGpuSize);
        gdaiClusterInfoVo.setAllUsedDiskSize(allUsedDiskSize);
        gdaiClusterInfoVo.setAllDevUsedCoreNumber(allDevUsedCoreNumber);
        gdaiClusterInfoVo.setAllDevUsedCpuSize(allDevUsedCpuSize);
        gdaiClusterInfoVo.setAllDevUsedGpuSize(allDevUsedGpuSize);
        gdaiClusterInfoVo.setAllDevUsedDiskSize(allDevUsedDiskSize);
        gdaiClusterInfoVo.setAllTrainUsedCoreNumber(allTrainUsedCoreNumber);
        gdaiClusterInfoVo.setAllTrainUsedCpuSize(allTrainUsedCpuSize);
        gdaiClusterInfoVo.setAllTrainUsedGpuSize(allTrainUsedGpuSize);
        gdaiClusterInfoVo.setAllTrainUsedDiskSize(allTrainUsedDiskSize);
        gdaiClusterInfoVo.setAllDeployUsedCoreNumber(allDeployUsedCoreNumber);
        gdaiClusterInfoVo.setAllDeployUsedCpuSize(allDeployUsedCpuSize);
        gdaiClusterInfoVo.setAllDeployUsedGpuSize(allDeployUsedGpuSize);
        gdaiClusterInfoVo.setAllDeployUsedDiskSize(allDeployUsedDiskSize);
    } catch (Exception e) {
        log.info("查询多个集群汇总信息异常", e);
        return RestResult.genFailResult("查询多个集群汇总信息异常");
    }
    return RestResult.genSuccessResult(gdaiClusterInfoVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为queryClusterInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryClusterInfo(GdaiClusterInfo gdaiClusterInfo) {
    log.info("GdaiClusterInfoServiceImpl.queryClusterInfo params: [{}]", JSON.toJSONString(gdaiClusterInfo));
    Long clusterId = gdaiClusterInfo.getClusterId();
    if (clusterId == null) {
        return RestResult.genFailResult("集群ID不能为空");
    }
    GdaiClusterInfo clusterInfo;
    try {
        clusterInfo = gdaiClusterInfoService.selectById(clusterId);
    } catch (Exception e) {
        log.info("查询集群信息异常", e);
        return RestResult.genFailResult("查询集群信息异常");
    }
    return RestResult.genSuccessResult(clusterInfo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiClusterInfoService gdaiClusterInfoService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为queryAllRes的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAllRes(GdaiClusterInfoVo gdaiClusterInfoVo) {
    log.info("GdaiClusterInfoServiceImpl.queryAllRes params: [{}]", JSON.toJSONString(gdaiClusterInfoVo));
    try {
        Long allClusterCoreNumber = gdaiClusterInfoMapper.getAllClusterCoreNumber();
        Long allClusterCpuSize = gdaiClusterInfoMapper.getAllClusterCpuSize();
        Long allClusterGpuSize = gdaiClusterInfoMapper.getAllClusterGpuSize();
        Long allClusterDiskSize = gdaiClusterInfoMapper.getAllClusterDiskSize();
        Long allProjectCoreNumber = gdaiProjectMapper.getAllProjectCoreNumber();
        Long allProjectCpuSize = gdaiProjectMapper.getAllProjectCpuSize();
        Long allProjectGpuSize = gdaiProjectMapper.getAllProjectGpuSize();
        Long allProjectDiskSize = gdaiProjectMapper.getAllProjectDiskSize();
        Long allClusterFreeCoreNumber = allClusterCoreNumber - allProjectCoreNumber;
        Long allClusterFreeCpuSize = allClusterCpuSize - allProjectCpuSize;
        Long allClusterFreeGpuSize = allClusterGpuSize - allProjectGpuSize;
        Long allClusterFreeDiskSize = allClusterDiskSize - allProjectDiskSize;
        gdaiClusterInfoVo.setAllClusterCoreNumber(allClusterCoreNumber);
        gdaiClusterInfoVo.setAllClusterCpuSize(allClusterCpuSize);
        gdaiClusterInfoVo.setAllClusterGpuSize(allClusterGpuSize);
        gdaiClusterInfoVo.setAllClusterDiskSize(allClusterDiskSize);
        gdaiClusterInfoVo.setAllProjectCoreNumber(allProjectCoreNumber);
        gdaiClusterInfoVo.setAllProjectCpuSize(allProjectCpuSize);
        gdaiClusterInfoVo.setAllProjectGpuSize(allProjectGpuSize);
        gdaiClusterInfoVo.setAllProjectDiskSize(allProjectDiskSize);
        gdaiClusterInfoVo.setAllClusterFreeCoreNumber(allClusterFreeCoreNumber);
        gdaiClusterInfoVo.setAllClusterFreeCpuSize(allClusterFreeCpuSize);
        gdaiClusterInfoVo.setAllClusterFreeGpuSize(allClusterFreeGpuSize);
        gdaiClusterInfoVo.setAllClusterFreeDiskSize(allClusterFreeDiskSize);
    } catch (Exception e) {
        log.info("查询多个集群汇总信息异常", e);
        return RestResult.genFailResult("查询多个集群汇总信息异常");
    }
    return RestResult.genSuccessResult(gdaiClusterInfoVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为checkGdaiClusterInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiClusterInfo checkGdaiClusterInfo(User user, Long clusterId) throws TrainginCenterException {
    GdaiClusterInfo clusterInfo = gdaiClusterInfoMapper.selectById(clusterId);
    if (clusterInfo == null) {
        throw new TrainginCenterException("记录不存在");
    } else {
        //判断登录用户角色
        //运营管理员角色
        boolean operAdminRole = SessionUtils.isOperAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(operAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(clusterInfo.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return clusterInfo;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为syncAllClusterResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult syncAllClusterResource() throws Exception {
    log.info("GdaiClusterInfoServiceImpl.syncClusterResource ");
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        List<GdaiClusterInfo> clusterInfoList = gdaiClusterInfoMapper.selectList(new EntityWrapper<>());
        for (GdaiClusterInfo clusterInfo : clusterInfoList) {
            syncClusterResource(clusterInfo.getClusterId());
        }
    } catch (Exception e) {
        log.info("同步节点信息异常", e);
        return RestResult.genFailResult("同步节点信息异常");
    }
    return RestResult.genSuccessResult("同步节点信息成功");
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.List
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiClusterInfoServiceImpl中有一个名为syncClusterResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult syncClusterResource(Long clusterId) throws Exception {
    log.info("GdaiClusterInfoServiceImpl.syncClusterResource params: [{}]", clusterId);
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiClusterInfo clusterInfo = checkGdaiClusterInfo(user, clusterId);
    try {
        List<GdaiNodeInfo> nodeInfoList = gdaiNodeInfoMapper.selectList(new EntityWrapper<GdaiNodeInfo>().eq(clusterId != null, "cluster_id", clusterId));
        for (GdaiNodeInfo nodeInfo : nodeInfoList) {
            gdaiNodeInfoService.updateNodeResourceByIp(clusterInfo.getClusterName(), nodeInfo.getNodeIp());
        }
        GdaiClusterInfo fromNodeInfo = gdaiClusterInfoMapper.sumFromNode(clusterId);
        CopyOptions copyOptions = new CopyOptions();
        copyOptions.ignoreNullValue();
        BeanUtil.copyProperties(fromNodeInfo, clusterInfo, copyOptions);
        gdaiClusterInfoMapper.updateById(clusterInfo);
    } catch (Exception e) {
        log.info("同步节点信息异常", e);
        return RestResult.genFailResult("同步节点信息异常");
    }
    return RestResult.genSuccessResult("同步节点信息成功");
}
### 类导入的包
cn.hutool.core.bean.BeanUtil
cn.hutool.core.bean.copier.CopyOptions
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiClusterInfoService
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.List
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelServiceImpl中有一个名为addBatch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addBatch(List<GdaiDatafileLabel> list) {
    log.info("GdaiDatafileLabelServiceImpl.addBatch params:" + JSON.toJSONString(list));
    //获取登录用户信息
    if (CollectionUtil.isEmpty(list)) {
        return RestResult.genFailResult("参数不能为空");
    }
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    Date curDate = new Date();
    try {
        //删除该文件对应的坐标信息
        gdaiDatafileLabelMapper.deleteByCondition(new GdaiDatafileLabel(list.get(0).getDatasetId(), list.get(0).getDatafileId()));
        //            gdaiDatafileLabelMapper.deleteBatch(list);
        //            if (list != null && list.size() > 0) {
        for (GdaiDatafileLabel gdaiDatafileLabel : list) {
            gdaiDatafileLabel.setCreateTime(curDate);
            gdaiDatafileLabel.setModifyTime(curDate);
            gdaiDatafileLabel.setCreatorId(userId);
        }
        gdaiDatafileLabelMapper.addBatch(list);
        //            } else {
        //                return RestResult.genFailResult("参数不能为空");
        //            }
    } catch (Exception e) {
        log.info("新增标签坐标异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelService
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelServiceImpl中有一个名为addBatchFromCsvFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param datasetId     数据集id
     * @param confirmStatus 待确认状态值     0- 生成待确认标注，数量为‘配置中待确认数’条记录   1-生成已确认标注，数量为除‘配置中待确认数’ 条记录
     * @param csvFilePath   推理结果文件（相对路径）
     * @param threshold     阈值，有阈值的数据集类型可以传，没的传0，不会影响结果， 只是返回值中统计用。
     * @return nanliCount是少于阈值的数量，effectiveCount是有推理结果的数量
     * {
     * "success": 0,
     * "code": "200",
     * "message": "新增成功",
     * "data": {
     * "nanliCount": 15,
     * "effectiveCount": 17,
     * "resultCount": 10,
     * "totalCount": 18
     * }
     * }
     */
public RestResult addBatchFromCsvFile(Long datasetId, String confirmStatus, String csvFilePath, Float threshold) {
    log.info(String.format("开始标注任务分配: %s， %s， %s， %s。", datasetId, confirmStatus, csvFilePath, threshold));
    long startTime = System.currentTimeMillis();
    //该map用来存放用户与子任务对应关系数据
    Date date = new Date();
    List<GdaiDatafileLabel> datafileLabelList = new ArrayList<>();
    List<GdaiDatafile> datafileList = new ArrayList<>();
    GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
    Long creatorId = dataset.getCreatorId();
    //从csv文件取数据
    List<CSVRecord> records = FileUtil.readCSV(dataset.getDatasetCephPath() + csvFilePath);
    if (records == null || records.size() <= 1) {
        return RestResult.genFailResult("标注文件没有数据");
    }
    //查询labels
    Map<Integer, Map<String, String>> map = new HashMap<>();
    Map<String, String> generateFileLabelMap = new HashMap<>();
    GdaiDatalabelVo gdaiDatalabelVo = new GdaiDatalabelVo();
    gdaiDatalabelVo.setDatasetId(datasetId);
    List<GdaiDatalabelVo> labels = gdaiDatalabelMapper.queryLabel(gdaiDatalabelVo);
    //按查询顺序生成标注index,一定要与前端保持一致的顺序
    for (int i = 0; i < labels.size(); i++) {
        Map<String, String> labelMap = new HashMap<>();
        labelMap.put("datalabel_id", String.valueOf(labels.get(i).getDatalabelId()));
        labelMap.put("label_name", String.valueOf(labels.get(i).getLabelName()));
        map.put(i, labelMap);
        generateFileLabelMap.put(String.valueOf(labels.get(i).getLabelName()), String.valueOf(i));
    }
    //第一行为标题行，所以从第二行开始处理
    records = records.subList(1, records.size());
    JSONObject result = new JSONObject();
    Integer count = 10;
    Integer resultCount = 0;
    Integer totalCount = records.size();
    //推理数
    result.put("totalCount", totalCount);
    //        if (Objects.equals(confirmStatus, "0")) {
    //            if(nanliCount == 0){
    //                //待标记数/标记数
    //                result.put("resultCount", resultCount);
    //                log.info("addBatchFromCsvFile result:"+JSON.toJSONString(result));
    //                return RestResult.genSuccessResult("没有达到阈值的难例", result);
    //            }
    //        }
    //
    //        List<CSVRecord> nanliRecords = new ArrayList<>();
    //        if (nanliCount >= count) {
    //            //最多取10个
    //            nanliRecords = records.stream().limit(count).collect(Collectors.toList());
    //        } else {
    //            nanliRecords = records.stream()
    //                    .filter(record -> Float.valueOf(record.get(2)) < threshold)
    //                    .collect(Collectors.toList());
    //        }
    //
    //        List<CSVRecord> tempList = new ArrayList<>();
    //        if (Objects.equals(confirmStatus, "0")) {
    //            //待确认 取生成的难例
    //            tempList = nanliRecords;
    //        } else {
    //            //确认 除去已生成的难例外的数据
    //            List<CSVRecord> finalNanliRecords = nanliRecords;
    //            tempList = records.stream().filter(record-> !finalNanliRecords.contains(record)).collect(Collectors.toList());
    //        }
    //        //待标记数 or 标记数
    //        resultCount = tempList.size();
    //        result.put("resultCount", resultCount);
    //        log.info("addBatchFromCsvFile result:"+JSON.toJSONString(result));
    //label_data
    JSONObject labelData = new JSONObject();
    String annotationType = dataset.getAnnotationType();
    String annotationTemplate = dataset.getAnnotationTemplate();
    //图像
    if (Objects.equals(annotationType.toLowerCase(), "OBJDET".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "RECTANGLE".toLowerCase())) {
        //物体检测-矩形标注框
        return RestResult.genFailResult("暂不支持该数据集类型");
    } else if (Objects.equals(annotationType.toLowerCase(), "imgcls".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "imgcls".toLowerCase())) {
        //图像分类-单图单标签
        count = imgclsCount;
        List<CSVRecord> tempList = new ArrayList<>();
        if (Objects.equals(confirmStatus, "0")) {
            //待确认 取生成的难例
            tempList = records.stream().limit(count).collect(Collectors.toList());
        } else {
            //确认 除去已生成的难例外的数据
            tempList = records.stream().skip(count).collect(Collectors.toList());
        }
        //待标记数 or 标记数
        resultCount = tempList.size();
        result.put("resultCount", resultCount);
        //把csv文件中的数据转换成实体类 生成GdaiDatafileLabel入库，更新GdaiDatafile
        for (CSVRecord csvRecord : tempList) {
            GdaiDatafile gdaiDatafile = new GdaiDatafile();
            //csv文件格式
            //image label
            ///datasets/trainDataset/shopee/test//BabyPants/BabyPants_1035.jpg	0
            //label->labelIndex
            String labelIndex = csvRecord.get(1);
            if (StringUtils.isEmpty(labelIndex) || !StringUtils.isNumeric(labelIndex)) {
                continue;
            }
            //image->fileName->datafile_Id
            String filePath = csvRecord.get(0);
            String fileName = FileNameUtil.getName(filePath);
            GdaiDatafile datafile = new GdaiDatafile();
            datafile.setDatasetId(datasetId);
            datafile.setFileName(fileName);
            gdaiDatafile = gdaiDatafileMapper.selectOne(datafile);
            if (gdaiDatafile == null) {
                continue;
            }
            //一个labelData 对一个 gdaiDatafileLabel
            Imgcls imgcls = new Imgcls(labelIndex, map.get(Integer.valueOf(labelIndex)).get("label_name"));
            labelData = JSON.parseObject(JSON.toJSONString(imgcls));
            GdaiDatafileLabel gdaiDatafileLabel = new GdaiDatafileLabel();
            gdaiDatafileLabel.setLabelData(labelData);
            gdaiDatafileLabel.setDatalabelId(Long.valueOf(map.get(Integer.valueOf(labelIndex)).get("datalabel_id")));
            gdaiDatafileLabel.setDatafileId(gdaiDatafile.getDatafileId());
            gdaiDatafileLabel.setDatasetId(datasetId);
            gdaiDatafileLabel.setCreateTime(date);
            gdaiDatafileLabel.setModifyTime(date);
            gdaiDatafileLabel.setCreatorId(creatorId);
            datafileLabelList.add(gdaiDatafileLabel);
            if (Objects.equals(confirmStatus, "0")) {
                //待确认 取生成的难例
                gdaiDatafile.setConfirmStatus("0");
                gdaiDatafile.setMarkStatus("1");
            } else {
                //确认 除去已生成的难例外的数据
                gdaiDatafile.setConfirmStatus("1");
                gdaiDatafile.setMarkStatus("2");
            }
            datafileList.add(gdaiDatafile);
        }
        if (threshold != null && threshold != 0) {
            //统计少于阈值的条数
            Integer nanliCount = (int) records.stream().filter(record -> Float.valueOf(record.get(2)) < threshold).count();
            //难例数
            result.put("nanliCount", nanliCount);
        }
    } else if (Objects.equals(annotationType.toLowerCase(), "segment".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Instance".toLowerCase())) {
        //图像分割-实例分割
        return RestResult.genFailResult("暂不支持该数据集类型");
    } else if (Objects.equals(annotationType.toLowerCase(), "segment".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Semantic".toLowerCase())) {
        //图像分割-语义分割
        return RestResult.genFailResult("暂不支持该数据集类型");
    } else //文本
    if (Objects.equals(annotationType.toLowerCase(), "Txtcls".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Txtcls".toLowerCase())) {
        //文本分类-单标签
        return RestResult.genFailResult("暂不支持该数据集类型");
    } else if (Objects.equals(annotationType.toLowerCase(), "Txtclsm".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Txtclsm".toLowerCase())) {
        //文本分类-多标签
        return RestResult.genFailResult("暂不支持该数据集类型");
    } else if (Objects.equals(annotationType.toLowerCase(), "TxtEntity".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "TxtEntity".toLowerCase())) {
        //文本实体抽取
        count = txtEntityCount;
        List<CSVRecord> tempList = new ArrayList<>();
        if (Objects.equals(confirmStatus, "0")) {
            //待确认 取生成的难例
            tempList = records.stream().limit(count).collect(Collectors.toList());
        } else {
            //确认 除去已生成的难例外的数据
            tempList = records.stream().skip(count).collect(Collectors.toList());
        }
        //待标记数 or 标记数
        resultCount = tempList.size();
        result.put("resultCount", resultCount);
        //把csv文件中的数据转换成实体类 生成GdaiDatafileLabel入库，更新GdaiDatafile
        for (CSVRecord csvRecord : tempList) {
            GdaiDatafile gdaiDatafile = new GdaiDatafile();
            //csv文件格式
            //text_snippet id entity_annotations
            //xxxxxxxxxxxxx 1 [{'entity_group': '4', 'start': 0, 'end': 16}, {'entity_group': '1', 'start': 22, 'end': 23}]
            String annotationsStr = csvRecord.get(2);
            if (StringUtils.isEmpty(annotationsStr)) {
                continue;
            }
            gdaiDatafile = gdaiDatafileMapper.selectById(csvRecord.get(1));
            if (gdaiDatafile == null) {
                continue;
            }
            //一个entity_annotations 对多个 gdaiDatafileLabel
            JSONArray annotations = JSONArray.parseArray(annotationsStr);
            for (int i = 0; i < annotations.size(); i++) {
                JSONObject annotation = annotations.getJSONObject(i);
                String labelIndex = annotation.getString("entity_group");
                //{"start":0,"end":16,"labelIndex":4,"labelName":"HCCX"}
                TxtEntity txtEntity = new TxtEntity(annotation.getLong("start"), annotation.getLong("end"), labelIndex, map.get(Integer.valueOf(labelIndex)).get("label_name"));
                //一个labelData 对一个 gdaiDatafileLabel
                labelData = JSON.parseObject(JSON.toJSONString(txtEntity));
                GdaiDatafileLabel gdaiDatafileLabel = new GdaiDatafileLabel();
                gdaiDatafileLabel.setLabelData(labelData);
                gdaiDatafileLabel.setDatalabelId(Long.valueOf(map.get(Integer.valueOf(labelIndex)).get("datalabel_id")));
                gdaiDatafileLabel.setDatafileId(gdaiDatafile.getDatafileId());
                gdaiDatafileLabel.setDatasetId(datasetId);
                gdaiDatafileLabel.setCreateTime(date);
                gdaiDatafileLabel.setModifyTime(date);
                gdaiDatafileLabel.setCreatorId(creatorId);
                datafileLabelList.add(gdaiDatafileLabel);
            }
            if (Objects.equals(confirmStatus, "0")) {
                //待确认 取生成的难例
                gdaiDatafile.setConfirmStatus("0");
                gdaiDatafile.setMarkStatus("1");
            } else {
                //确认 除去已生成的难例外的数据
                gdaiDatafile.setConfirmStatus("1");
                gdaiDatafile.setMarkStatus("2");
            }
            datafileList.add(gdaiDatafile);
        }
        Integer effectiveCount = (int) records.stream().filter(record -> {
            JSONArray array = JSONArray.parseArray(record.get(2));
            if (array.size() > 0) {
                return true;
            }
            return false;
        }).count();
        result.put("effectiveCount", effectiveCount);
    } else {
        return RestResult.genFailResult("未知的数据集类型");
    }
    try {
        if (datafileList.size() <= 0) {
            throw new Exception("筛选难倒为空");
        }
        gdaiDatafileMapper.updateBatch(datafileList);
        //删除该文件对应的坐标信息
        gdaiDatafileLabelMapper.deleteBatch(datafileLabelList);
        if (datafileLabelList != null && datafileLabelList.size() > 0) {
            gdaiDatafileLabelMapper.addBatch(datafileLabelList);
        } else {
            throw new Exception("参数不能为空");
        }
        if (Objects.equals(confirmStatus, "1")) {
            //
            GdaiDatafileVo gdaiDatafileVo = new GdaiDatafileVo();
            gdaiDatafileVo.setDatasetId(datasetId);
            gdaiDatafileVo.setLabelMap(generateFileLabelMap);
            gdaiDatafileService.generateFileBatch(gdaiDatafileVo);
        }
        long endTime = System.currentTimeMillis();
        float excTime = (float) (endTime - startTime) / 1000;
        log.info("任务分配完毕，总耗时：" + excTime + "秒");
        log.info("addBatchFromCsvFile result:" + JSON.toJSONString(result));
        return RestResult.genSuccessResult("新增成功", result);
    } catch (Exception e) {
        log.info("新增标签坐标异常", e);
        return RestResult.genFailResult("新增标签坐标异常" + e.getMessage());
    }
}
### 类导入的包
cn.hutool.core.io.file.FileNameUtil
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity
com.eshore.gdai.trainingcenter.model.pic.imgcls.Imgcls
com.eshore.gdai.trainingcenter.model.txt.txtentity.TxtEntity
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.GdaiDatalabelVo
org.apache.commons.csv.CSVRecord
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.stream.Collectors
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileService gdaiDatafileService;
/**
 * 文本实体抽取待确认数
 */
@Value("${dataset.txtEntity.txtEntity}")
private Integer txtEntityCount;
/**
 * 文本实体抽取待确认数
 */
@Value("${dataset.imgcls.imgcls}")
private Integer imgclsCount;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiDatafileLabel gdaiDatafileLabel) throws TrainginCenterException {
    log.info("GdaiDatafileLabelServiceImpl.update params:" + JSON.toJSONString(gdaiDatafileLabel));
    Long datafileLabelId = gdaiDatafileLabel.getDatalabelId();
    if (datafileLabelId == null) {
        return RestResult.genFailResult("文件标签ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatafileLabel datafileLabel = checkGdaiDatafileLabel(user, datafileLabelId);
    try {
        BeanUtils.copyProperties(gdaiDatafileLabel, datafileLabel);
        Date curDate = new Date();
        datafileLabel.setModifyTime(curDate);
        datafileLabel.setModifierId(user.getId());
        gdaiDatafileLabelMapper.updateById(datafileLabel);
    } catch (Exception e) {
        log.info("修改标签坐标异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelService
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelServiceImpl中有一个名为deleteByCondition的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteByCondition(GdaiDatafileLabel gdaiDatafileLabel) {
    log.info("GdaiDatafileLabelServiceImpl.deleteByCondition params:" + JSON.toJSONString(gdaiDatafileLabel));
    if (gdaiDatafileLabel == null) {
        RestResult.genFailResult("参数不能为空");
    }
    try {
        gdaiDatafileLabelMapper.deleteByCondition(gdaiDatafileLabel);
        //删除坐标的同时删除坐标文件
        Long datasetId = gdaiDatafileLabel.getDatasetId();
        Long datafileId = gdaiDatafileLabel.getDatafileId();
        if (datasetId != null && datafileId != null) {
            GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
            GdaiDatafile gdaiDatafile = gdaiDatafileMapper.selectById(datafileId);
            if (dataset != null && gdaiDatafile != null) {
                String datasetLabelPath = dataset.getDatasetLabelPath();
                String datasetFilePath = dataset.getDatasetFilePath();
                String[] split = gdaiDatafile.getFileName().split("\\.");
                boolean bo = FileUtil.deleteFile(datasetLabelPath + split[0] + ".txt");
                boolean bo2 = FileUtil.deleteFile(datasetFilePath + gdaiDatafile.getFileName());
                if (!bo || !bo2) {
                    log.info("GdaiDatafileLabelServiceImpl.deleteByCondition: 删除坐标文件失败");
                }
            }
        }
        //当最后一个坐标信息删除之后需要修改文件状态为未标注状态
    } catch (Exception e) {
        log.info("删除标签坐标异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelService
com.eshore.gdai.trainingcenter.util.FileUtil
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelServiceImpl中有一个名为queryFileLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryFileLabel(GdaiDatafileLabel gdaiDatafileLabel) {
    log.info("GdaiDatafileLabelServiceImpl.queryFileLabel params:" + JSON.toJSONString(gdaiDatafileLabel));
    List<GdaiDatafileLabel> gdaiDatafileLabels;
    try {
        gdaiDatafileLabels = gdaiDatafileLabelMapper.queryLabel(gdaiDatafileLabel);
    } catch (Exception e) {
        log.info("查询标签坐标异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiDatafileLabels);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelServiceImpl中有一个名为checkGdaiDatafileLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiDatafileLabel checkGdaiDatafileLabel(User user, Long datafileLabelId) throws TrainginCenterException {
    GdaiDatafileLabel datafileLabel = gdaiDatafileLabelMapper.selectById(datafileLabelId);
    if (datafileLabel == null) {
        throw new TrainginCenterException("未查询到该文件标签信息");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(datafileLabel.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return datafileLabel;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelTempServiceImpl中有一个名为addBatch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addBatch(List<GdaiDatafileLabelTemp> list) {
    log.info("GdaiDatafileLabelTempServiceImpl.addBatch params:" + JSON.toJSONString(list));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    Date curDate = new Date();
    try {
        //删除该文件对应的坐标信息
        gdaiDatafileLabelTempMapper.deleteByCondition(new GdaiDatafileLabelTemp(list.get(0).getDatasetId(), list.get(0).getDatafileId()));
        //            gdaiDatafileLabelTempMapper.deleteBatch(list);
        //            if (list != null && list.size() > 0) {
        for (GdaiDatafileLabelTemp gdaiDatafileLabelTemp : list) {
            gdaiDatafileLabelTemp.setCreateTime(curDate);
            gdaiDatafileLabelTemp.setModifyTime(curDate);
            gdaiDatafileLabelTemp.setCreatorId(userId);
        }
        gdaiDatafileLabelTempMapper.addBatch(list);
        //            } else {
        //                return RestResult.genFailResult("参数不能为空");
        //            }
    } catch (Exception e) {
        log.info("新增标签坐标异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelTempService
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelTempServiceImpl中有一个名为addBatchFromCsvFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addBatchFromCsvFile(Long datasetId, String csvFilePath) {
    List<GdaiDatafileLabelTemp> list = new ArrayList<>();
    GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
    //从csv文件取数据
    List<CSVRecord> records = FileUtil.readCSV(csvFilePath);
    //查询labels
    Map<Integer, Map<String, String>> map = new HashMap<>();
    GdaiDatalabelVo gdaiDatalabelVo = new GdaiDatalabelVo();
    gdaiDatalabelVo.setDatasetId(datasetId);
    List<GdaiDatalabelVo> labels = gdaiDatalabelMapper.queryLabel(gdaiDatalabelVo);
    for (int i = 0; i < labels.size(); i++) {
        Map<String, String> labelMap = new HashMap<>();
        labelMap.put("datalabel_id", String.valueOf(labels.get(i).getDatalabelId()));
        labelMap.put("label_name", String.valueOf(labels.get(i).getLabelName()));
        map.put(i, labelMap);
    }
    //把csv文件中的数据转换成实体类
    for (int i = 1; i < records.size(); i++) {
        GdaiDatafileLabelTemp gdaiDatafileLabelTemp = new GdaiDatafileLabelTemp();
        //datafile_Id
        String filePath = records.get(i).get(0);
        String fileName = FileNameUtil.getName(filePath);
        GdaiDatafile datafile = new GdaiDatafile();
        datafile.setDatasetId(datasetId);
        datafile.setFileName(fileName);
        GdaiDatafile gdaiDatafile = gdaiDatafileMapper.selectOne(datafile);
        if (gdaiDatafile == null) {
            break;
        }
        //datalabel_id
        String labelIndex = records.get(i).get(1);
        if (StringUtils.isEmpty(labelIndex) || !StringUtils.isNumeric(labelIndex)) {
            break;
        }
        //label_data
        JSONObject labelData = new JSONObject();
        String annotationType = dataset.getAnnotationType();
        String annotationTemplate = dataset.getAnnotationTemplate();
        //图像
        if (Objects.equals(annotationType.toLowerCase(), "OBJDET".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "RECTANGLE".toLowerCase())) {
            //物体检测-矩形标注框
        } else if (Objects.equals(annotationType.toLowerCase(), "imgcls".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "imgcls".toLowerCase())) {
            //图像分类-单图单标签
            Imgcls imgcls = new Imgcls();
            imgcls.setLabelIndex(map.get(Integer.valueOf(labelIndex)).get("datalabel_id"));
            imgcls.setLabelName(map.get(Integer.valueOf(labelIndex)).get("label_name"));
            labelData = JSON.parseObject(JSON.toJSONString(imgcls));
        } else if (Objects.equals(annotationType.toLowerCase(), "segment".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Instance".toLowerCase())) {
            //图像分割-实例分割
        } else if (Objects.equals(annotationType.toLowerCase(), "segment".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Semantic".toLowerCase())) {
            //图像分割-语义分割
        } else //文本
        if (Objects.equals(annotationType.toLowerCase(), "Txtcls".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Txtcls".toLowerCase())) {
            //文本分类-单标签
        } else if (Objects.equals(annotationType.toLowerCase(), "Txtclsm".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Txtclsm".toLowerCase())) {
            //文本分类-多标签
        } else if (Objects.equals(annotationType.toLowerCase(), "TxtEntity".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "TxtEntity".toLowerCase())) {
            //文本实体抽取
        } else {
        }
        gdaiDatafileLabelTemp.setDatafileId(gdaiDatafile.getDatafileId());
        gdaiDatafileLabelTemp.setDatalabelId(Long.valueOf(map.get(Integer.valueOf(labelIndex)).get("datalabel_id")));
        gdaiDatafileLabelTemp.setDatasetId(datasetId);
        gdaiDatafileLabelTemp.setLabelData(labelData);
        list.add(gdaiDatafileLabelTemp);
    }
    Long userId = 0L;
    Date curDate = new Date();
    try {
        //删除该文件对应的坐标信息
        gdaiDatafileLabelTempMapper.deleteBatch(list);
        if (list != null && list.size() > 0) {
            for (GdaiDatafileLabelTemp gdaiDatafileLabelTemp : list) {
                gdaiDatafileLabelTemp.setCreateTime(curDate);
                gdaiDatafileLabelTemp.setModifyTime(curDate);
                gdaiDatafileLabelTemp.setCreatorId(userId);
            }
            gdaiDatafileLabelTempMapper.addBatch(list);
        } else {
            return RestResult.genFailResult("参数不能为空");
        }
    } catch (Exception e) {
        log.info("新增标签坐标异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
cn.hutool.core.io.file.FileNameUtil
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.model.pic.imgcls.Imgcls
com.eshore.gdai.trainingcenter.model.pic.segment.Instance
com.eshore.gdai.trainingcenter.model.txt.txtcls.Txtcls
com.eshore.gdai.trainingcenter.model.txt.txtclsm.Txtclsm
com.eshore.gdai.trainingcenter.model.txt.txtentity.TxtEntity
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatalabelVo
org.apache.commons.csv.CSVRecord
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelTempServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiDatafileLabelTemp gdaiDatafileLabelTemp) throws TrainginCenterException {
    log.info("GdaiDatafileLabelTempServiceImpl.update params:" + JSON.toJSONString(gdaiDatafileLabelTemp));
    Long datafileLabelId = gdaiDatafileLabelTemp.getDatalabelId();
    if (datafileLabelId == null) {
        return RestResult.genFailResult("文件标签ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatafileLabelTemp datafileLabelTemp = checkGdaiDatafileLabelTemp(user, datafileLabelId);
    try {
        BeanUtils.copyProperties(gdaiDatafileLabelTemp, datafileLabelTemp);
        Date curDate = new Date();
        datafileLabelTemp.setModifyTime(curDate);
        datafileLabelTemp.setModifierId(user.getId());
        gdaiDatafileLabelTempMapper.updateById(datafileLabelTemp);
    } catch (Exception e) {
        log.info("修改标签坐标异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelTempService
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelTempServiceImpl中有一个名为deleteByCondition的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteByCondition(GdaiDatafileLabelTemp gdaiDatafileLabelTemp) {
    log.info("GdaiDatafileLabelTempServiceImpl.deleteByCondition params:" + JSON.toJSONString(gdaiDatafileLabelTemp));
    if (gdaiDatafileLabelTemp == null) {
        RestResult.genFailResult("参数不能为空");
    }
    try {
        gdaiDatafileLabelTempMapper.deleteByCondition(gdaiDatafileLabelTemp);
        //删除坐标的同时删除坐标文件
        Long datasetId = gdaiDatafileLabelTemp.getDatasetId();
        Long datafileId = gdaiDatafileLabelTemp.getDatafileId();
        if (datasetId != null && datafileId != null) {
            GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
            GdaiDatafile gdaiDatafile = gdaiDatafileMapper.selectById(datafileId);
            if (dataset != null && gdaiDatafile != null) {
                String datasetLabelPath = dataset.getDatasetLabelPath();
                String datasetFilePath = dataset.getDatasetFilePath();
                String[] split = gdaiDatafile.getFileName().split("\\.");
                boolean bo = FileUtil.deleteFile(datasetLabelPath + split[0] + ".txt");
                boolean bo2 = FileUtil.deleteFile(datasetFilePath + gdaiDatafile.getFileName());
                if (!bo || !bo2) {
                    log.info("GdaiDatafileLabelTempServiceImpl.deleteByCondition: 删除坐标文件失败");
                }
            }
        }
        //当最后一个坐标信息删除之后需要修改文件状态为未标注状态(前端已处理)
    } catch (Exception e) {
        log.info("删除标签坐标异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelTempService
com.eshore.gdai.trainingcenter.util.FileUtil
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelTempServiceImpl中有一个名为queryFileLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryFileLabel(GdaiDatafileLabelTemp gdaiDatafileLabelTemp) {
    log.info("GdaiDatafileLabelTempServiceImpl.queryFileLabel params:" + JSON.toJSONString(gdaiDatafileLabelTemp));
    List<GdaiDatafileLabel> gdaiDatafileLabels;
    try {
        gdaiDatafileLabels = gdaiDatafileLabelTempMapper.queryLabel(gdaiDatafileLabelTemp);
    } catch (Exception e) {
        log.info("查询标签坐标异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiDatafileLabels);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.service.GdaiDatafileLabelTempService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileLabelTempServiceImpl中有一个名为checkGdaiDatafileLabelTemp的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiDatafileLabelTemp checkGdaiDatafileLabelTemp(User user, Long datafileLabelTempId) throws TrainginCenterException {
    GdaiDatafileLabelTemp datafileLabelTemp = gdaiDatafileLabelTempMapper.selectById(datafileLabelTempId);
    if (datafileLabelTemp == null) {
        throw new TrainginCenterException("未查询到该文件标签信息");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(datafileLabelTemp.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return datafileLabelTemp;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
### 类级别的变量
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为addBatch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addBatch(List<GdaiDatafile> list) {
    log.info("GdaiDatafileServiceImpl.addBatch params: " + JSON.toJSONString(list));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    Date curDate = new Date();
    try {
        if (list != null && list.size() > 0) {
            for (GdaiDatafile gdaiDatafile : list) {
                gdaiDatafile.setCreateTime(curDate);
                gdaiDatafile.setModifyTime(curDate);
                gdaiDatafile.setCreatorId(userId);
            }
            gdaiDatafileMapper.addBatch(list);
        } else {
            return RestResult.genFailResult("参数不能为空");
        }
    } catch (Exception e) {
        log.info("新增文件信息异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiDatafile gdaiDatafile) throws TrainginCenterException {
    log.info("GdaiDatafileServiceImpl.update params: {}", JSON.toJSONString(gdaiDatafile));
    Long datafileId = gdaiDatafile.getDatafileId();
    if (datafileId == null) {
        return RestResult.genFailResult("文件ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatafile datafile = checkRoleGdaiDatafile(user, datafileId);
    try {
        BeanUtils.copyProperties(gdaiDatafile, datafile);
        Date curDate = new Date();
        datafile.setModifyTime(curDate);
        datafile.setModifierId(user.getId());
        gdaiDatafileMapper.updateById(datafile);
    } catch (Exception e) {
        log.info("修改文件信息异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为updateByDatafileId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateByDatafileId(GdaiDatafile gdaiDatafile) throws TrainginCenterException {
    log.info("GdaiDatafileServiceImpl.updateByDatafileId params: " + JSON.toJSONString(gdaiDatafile));
    Long datasetId = gdaiDatafile.getDatasetId();
    Long datafileId = gdaiDatafile.getDatafileId();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (datafileId == null) {
        return RestResult.genFailResult("文件ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatafile datafile = checkGdaiDatafile(user, datafileId);
    try {
        //修改文件标注状态之前查询该文件是否还有标注坐标信息，若没有则修改为1-待标注
        int count = gdaiDatafileLabelMapper.selectCount(new EntityWrapper<GdaiDatafileLabel>().eq("dataset_id", datasetId).eq("datafile_id", datafileId));
        if (count == 0) {
            //mark_status 数据标注状态：1-待标注 2-标注中 3-已提交 4-结束标注(标注保留) 5-结束标注(标注不保留) 6-验收已完成
            Date curDate = new Date();
            gdaiDatafileMapper.updateById(new GdaiDatafile(datafileId, "1", curDate, user.getId()));
        }
    } catch (Exception e) {
        log.info("根据文件ID修改标注状态异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为deleteBatch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteBatch(List<GdaiDatafile> list) throws TrainginCenterException {
    log.info("GdaiDatafileServiceImpl.deleteBatch params: " + JSON.toJSONString(list));
    if (list == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    List<GdaiDatafileLabel> labelList = new ArrayList<>();
    GdaiDatafileLabel gdaiDatafileLabel;
    for (GdaiDatafile file : list) {
        //修复水平越权问题
        GdaiDatafile datafile = checkGdaiDatafile(user, file.getDatafileId());
        gdaiDatafileLabel = new GdaiDatafileLabel();
        gdaiDatafileLabel.setDatasetId(file.getDatasetId());
        gdaiDatafileLabel.setDatafileId(file.getDatafileId());
        labelList.add(gdaiDatafileLabel);
    }
    try {
        //删除文件信息
        //            gdaiDatafileMapper.deleteBatch(list);
        gdaiDatafileMapper.deleteBatchV1(list);
        //删除该文件对应的坐标信息
        gdaiDatafileLabelMapper.deleteBatch(labelList);
        //删除cephfs上该图片的信息，删除之前需确定该图片已经没有其他数据集使用才能删除
        for (GdaiDatafile file : list) {
            int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("file_name", file.getFileName()));
            if (fileCount == 0) {
                //根据文件名称查询所有数据集下是否还有存在，如果不存在则删除cephfs上该图片的信息
                boolean bo1 = false;
                boolean bo2 = false;
                boolean bo3 = false;
                boolean bo4 = false;
                boolean bo5 = false;
                String[] split = file.getFileName().split("\\.");
                if (StringUtils.isNotBlank(file.getCephUrl())) {
                    bo1 = FileUtil.deleteFile(file.getCephUrl());
                    //删除对应的json标注文件
                    String jsonUrl = file.getCephUrl().replace(split[1], "json");
                    bo2 = FileUtil.deleteFile(jsonUrl);
                }
                if (StringUtils.isNotBlank(file.getIconUrl())) {
                    bo3 = FileUtil.deleteFile(file.getIconUrl());
                }
                //根据数据集ID查询出copy的另一份文件存储目录并删除
                Long datasetId = file.getDatasetId();
                GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
                if (dataset != null) {
                    String datasetFilePath = dataset.getDatasetFilePath();
                    String datasetLabelPath = dataset.getDatasetLabelPath();
                    if (StringUtils.isNotBlank(datasetFilePath)) {
                        bo4 = FileUtil.deleteFile(datasetFilePath + file.getFileName());
                    }
                    if (StringUtils.isNotBlank(datasetLabelPath)) {
                        bo5 = FileUtil.deleteFile(datasetLabelPath + split[0] + ".txt");
                    }
                }
                if (!bo1 || !bo2 || !bo3 || !bo4 || !bo5) {
                    log.info("删除失败");
                }
            }
        }
    } catch (Exception e) {
        log.info("删除文件信息异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryListByDatasetId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<UiPage<GdaiDatafileVo>> queryListByDatasetId(GdaiDatafileVo datafileVo) {
    log.info("GdaiDatafileServiceImpl.queryListByDatasetId params: " + JSON.toJSONString(datafileVo));
    if (datafileVo == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    UiPage<GdaiDatafileVo> newUiPage = new UiPage<>();
    List<GdaiDatafileVo> fileVoList = new ArrayList<>();
    GdaiDatafileVo gdaiDatafileVo;
    List<String> desc = new ArrayList<>();
    //        desc.add("modify_time");
    desc.add("datafile_id");
    Page<GdaiDatafile> gdaiDatafile = null;
    String markStatus = datafileVo.getMarkStatus();
    try {
        if (StringUtils.isNotBlank(markStatus)) {
            if ("4".equals(markStatus)) {
                //查询全部图片信息
                datafileVo.setMarkStatus("1,2,3");
            } else if ("2".equals(markStatus)) {
                datafileVo.setMarkStatus("2,3");
            }
            gdaiDatafile = gdaiDatafileService.selectPage(new Page<>(datafileVo.getPageNumber(), datafileVo.getPageCount()), new EntityWrapper<GdaiDatafile>().eq("dataset_id", datafileVo.getDatasetId()).in("mark_status", datafileVo.getMarkStatus()).orderDesc(desc));
        }
        if (StringUtils.isNotBlank(datafileVo.getConfirmStatus())) {
            gdaiDatafile = gdaiDatafileService.selectPage(new Page<>(datafileVo.getPageNumber(), datafileVo.getPageCount()), new EntityWrapper<GdaiDatafile>().eq("dataset_id", datafileVo.getDatasetId()).eq("confirm_status", datafileVo.getConfirmStatus()));
        }
        List<String> strings = null;
        if (gdaiDatafile != null) {
            UiPage<GdaiDatafile> uiPage = ReturnJson.turnUiPage(gdaiDatafile);
            if (uiPage != null && uiPage.getList().size() > 0) {
                List<GdaiDatafile> gdaiDatafileList = uiPage.getList();
                newUiPage.setPageSize(uiPage.getPageSize());
                newUiPage.setPageNum(uiPage.getPageNum());
                newUiPage.setTotal(uiPage.getTotal());
                newUiPage.setPages(uiPage.getPages());
                for (GdaiDatafile fileInfo : gdaiDatafileList) {
                    String status = fileInfo.getMarkStatus();
                    gdaiDatafileVo = new GdaiDatafileVo();
                    if (!"3".equals(status)) {
                        //根据datafileId和datasetId查询该数据集下所有标注坐标
                        List<GdaiDatafileLabelVo> gdaiDatafileLabelVos = gdaiDatafileLabelMapper.queryLabelAndOther(new GdaiDatafileLabel(fileInfo.getDatasetId(), fileInfo.getDatafileId()));
                        gdaiDatafileVo.setFileLabels(gdaiDatafileLabelVos);
                        //获取datafileId和datasetId，根据其查询标签名称
                        if (fileInfo.getDatafileId() != null && fileInfo.getDatasetId() != null) {
                            strings = gdaiDatalabelMapper.queryLabelName(new GdaiDatafile(fileInfo.getDatafileId(), fileInfo.getDatasetId()));
                            gdaiDatafileVo.setLabelName(strings);
                        } else {
                            gdaiDatafileVo.setLabelName(strings);
                        }
                    } else {
                        gdaiDatafileVo.setFileLabels(null);
                        gdaiDatafileVo.setLabelName(null);
                    }
                    //如果markStatus为3则表示为无效数据，无效数据坐标表没有记录。特殊处理
                    //根据iconUrl去ceph下载对应文件流并转换为base64
                    if (StringUtils.isNotBlank(fileInfo.getIconUrl())) {
                        String base64 = FileUtil.getFileStream2Base64(fileInfo.getIconUrl());
                        gdaiDatafileVo.setIconBase64(base64);
                    }
                    BeanUtils.copyProperties(fileInfo, gdaiDatafileVo);
                    fileVoList.add(gdaiDatafileVo);
                }
                newUiPage.setList(fileVoList);
            }
        }
    } catch (Exception e) {
        log.info("查询文件信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(newUiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.ReturnJson
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileService gdaiDatafileService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为upload的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult upload(GdaiDatafileVo datafileVo) {
    log.info("GdaiDatafileServiceImpl.upload");
    List<MultipartFile> files = datafileVo.getFiles();
    Long datasetId = datafileVo.getDatasetId();
    String markStatus = datafileVo.getMarkStatus();
    String datasetCephPath = datafileVo.getDatasetCephPath();
    if (files == null) {
        return RestResult.genFailResult("上传文件不能为空");
    }
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (StringUtils.isBlank(markStatus)) {
        return RestResult.genFailResult("有无标注信息不能为空");
    }
    if (StringUtils.isBlank(datasetCephPath)) {
        return RestResult.genFailResult("存放路径不能为空");
    }
    List<GdaiDatafile> fileList = new ArrayList<>();
    File destPath;
    String uploadPath;
    try {
        long startTime = System.currentTimeMillis();
        GdaiDatafile gdaiDatafile;
        for (MultipartFile next : files) {
            //获取文件大小
            long size = next.getSize();
            //获取文件名称
            String originalFilename = next.getOriginalFilename();
            //校验上传图片类型
            boolean validImageExtension = FileUtil.isValidImageExtension(originalFilename);
            if (!validImageExtension) {
                return RestResult.genFailResult("上传图片必须为jpg,png,或jpeg中的一种");
            }
            //获取当前数据集文件存储路径
            destPath = FileUtils.getFile(datasetCephPath);
            uploadPath = destPath + "/source/";
            if (!(FileUtils.getFile(uploadPath)).exists()) {
                FileUtil.createDir(uploadPath);
            }
            //上传文件到项目临时目录
            File tempPath = FileUtils.getFile(uploadPath + originalFilename);
            next.transferTo(tempPath);
            //对临时文件进行重命名
            String[] split = originalFilename.split("\\.");
            String newFileName = UuidUtils.uuid() + "." + split[1];
            String oldPath = uploadPath + originalFilename;
            String newPath = uploadPath + newFileName;
            FileUtils.getFile(oldPath).renameTo(FileUtils.getFile(newPath));
            //调用封装方法，将原始图片转成微缩图
            byte[] fileBytes = picTransformStream(newPath);
            //获取图片尺寸(使用ImageIO.read读取时警惕部分图片为webp格式，这种格式的图片读取时返回为null,将图片用记事本打开即可查看真实格式)
            BufferedImage originalImage = ImageIO.read(new ByteArrayInputStream(fileBytes));
            int height = originalImage.getHeight();
            int width = originalImage.getWidth();
            BufferedImage bufferedImage = Thumbnails.of(originalImage).scale(Double.parseDouble(scale)).asBufferedImage();
            //将转换后的微缩图也上传ceph
            String iconName = "thumb_" + newFileName;
            //微缩图转为输入流,将微缩图流转为MultipartFile类型
            MultipartFile multipartFile = FileUtil.getMultipartFile(FileUtil.bufferedImageToInputStream(bufferedImage), iconName);
            //创建微缩图上传路径
            String path = datasetCephPath + "/thumb/";
            if (!(FileUtils.getFile(path)).exists()) {
                FileUtil.createDir(path);
            }
            multipartFile.transferTo(FileUtils.getFile(path + iconName));
            gdaiDatafile = new GdaiDatafile();
            gdaiDatafile.setDatasetId(datasetId);
            gdaiDatafile.setFileName(newFileName);
            gdaiDatafile.setCephUrl(newPath);
            gdaiDatafile.setIconUrl(path + iconName);
            gdaiDatafile.setFileSize(size);
            gdaiDatafile.setScreenH(height);
            gdaiDatafile.setScreenW(width);
            gdaiDatafile.setConfirmStatus("1");
            gdaiDatafile.setMarkStatus(markStatus);
            gdaiDatafile.setRemarks(originalFilename);
            //解决字段非空约束,默认赋值为空
            gdaiDatafile.setShortText(" ");
            gdaiDatafile.setFileData(" ");
            fileList.add(gdaiDatafile);
        }
        //批量新增文件信息入库
        addBatch(fileList);
        //全部导入完毕修改新数据集导入状态为已完成-S0I
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setImpStatus("S0I");
        set.setModifyTime(new Date());
        gdaiDatasetMapper.updateById(set);
        long endTime = System.currentTimeMillis();
        float excTime = (float) (endTime - startTime) / 1000;
        log.info("导入图片完毕，总耗时：" + excTime + "秒");
    } catch (Exception e) {
        log.info("导入图片异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        //新数据集导入异常修改状态为导入失败-S0F
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setImpStatus("S0F");
        set.setModifyTime(new Date());
        gdaiDatasetMapper.updateById(set);
        return RestResult.genFailResult("导入图片异常");
    }
    return RestResult.genSuccessResult("图片导入成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.vo.Result
com.google.common.io.Files
net.coobird.thumbnailator.Thumbnails
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
org.springframework.web.multipart.MultipartFile
javax.imageio.ImageIO
java.awt.image.BufferedImage
java.io.ByteArrayInputStream
java.io.File
java.io.InputStream
java.util.ArrayList
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
/**
 * 图片压缩比例
 */
@Value("${file.scale}")
private String scale;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为checkFileMd5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> checkFileMd5(String md5, String fileName, String datasetCephPath) {
    log.info("GdaiDatafileServiceImpl.checkFileMd5 params: [{}],[{}]", fileName, datasetCephPath);
    try {
        Result result = LocalUpload.checkFileMd5(md5, fileName, datasetCephPath + breakpointConfPath, datasetCephPath + breakpointPath);
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("MD5检查异常", e);
    }
    return RestResult.genFailResult("MD5检查异常");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.io.File
### 类级别的变量
/**
 * 断点续传文件目录
 */
@Value("${cephUpload.breakpointPath}")
private String breakpointPath;
/**
 * 断点续传conf文件目录
 */
@Value("${cephUpload.breakpointConfPath}")
private String breakpointConfPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为breakpointUpload的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> breakpointUpload(GdaiDatafileVo gdaiDatafileVo, HttpServletRequest request) {
    log.info("GdaiDatafileServiceImpl.breakpointUpload params: [{}],[{}],[{}],[{}],[{}]", gdaiDatafileVo.getId(), gdaiDatafileVo.getChunks(), gdaiDatafileVo.getChunk(), gdaiDatafileVo.getSize(), gdaiDatafileVo.getName());
    try {
        //获取断点续传参数
        String id = gdaiDatafileVo.getId();
        int chunks = gdaiDatafileVo.getChunks();
        int chunk = gdaiDatafileVo.getChunk();
        long size = gdaiDatafileVo.getSize();
        String name = gdaiDatafileVo.getName();
        MultipartFile file = gdaiDatafileVo.getFile();
        String md5 = gdaiDatafileVo.getMd5();
        //获取上传根目录
        String datasetCephPath = gdaiDatafileVo.getDatasetCephPath();
        //拼装上传压缩包目录
        String filePath = datasetCephPath + breakpointPath;
        String confFilePath = datasetCephPath + breakpointConfPath;
        // 这里的 chunkSize(分片大小) 要与前端传过来的大小一致
        Result result = LocalUpload.fragmentFileUploader(new UploadFileParam(id, chunks, chunk, size, name, file, md5), confFilePath, filePath, 5242880L, request);
        result.setData(filePath);
        String code = result.getCode();
        //状态码为201时表示文件上传完毕，此时对压缩包进行校验
        if ("201".equals(code)) {
            //对压缩包进行合法性检查
            String srcZipPath = filePath + "/" + name;
            //添加允许的扩展名
            String[] fileTypesArray = allowedFileType.split(",");
            // 转换字符串数组为List
            List<String> allowedExtensions = Arrays.stream(fileTypesArray).map(String::trim).collect(Collectors.toList());
            boolean isValid = FileUtil.validateZipFileContainsOnlyAllowedTypes(srcZipPath, allowedExtensions);
            if (!isValid) {
                //校验不通过删除压缩包
                String filePathName = filePath + "/" + name;
                String confFilePathName = confFilePath + "/" + name + ".conf";
                if (StringUtils.isNotBlank(filePathName)) {
                    File files = FileUtils.getFile(filePathName);
                    if (files.exists()) {
                        FileUtil.deleteFile(files);
                    }
                }
                if (StringUtils.isNotBlank(confFilePathName)) {
                    File confFile = FileUtils.getFile(confFilePathName);
                    if (confFile.exists()) {
                        FileUtil.deleteFile(confFile);
                    }
                }
                return RestResult.genFailResult("压缩包为空或者压缩包中包含不允许的文件类型,请删除后重新上传");
            }
        }
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("上传文件异常", e);
    }
    return RestResult.genFailResult("上传失败");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
com.eshore.gdai.trainingcenter.vo.UploadFileParam
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.Arrays
java.util.List
java.util.stream.Collectors
### 类级别的变量
/**
 * 断点续传文件目录
 */
@Value("${cephUpload.breakpointPath}")
private String breakpointPath;
/**
 * 断点续传conf文件目录
 */
@Value("${cephUpload.breakpointConfPath}")
private String breakpointConfPath;
@Autowired
private HttpServletRequest request;
/**
 * 允许上传的文件类型
 */
@Value("${upload.allowedFileType}")
private String allowedFileType;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为deleteBreakpointFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteBreakpointFile(GdaiDatafileVo gdaiDatafileVo) {
    log.info("GdaiDatafileServiceImpl.deleteBreakpointFile params: " + JSON.toJSONString(gdaiDatafileVo));
    String fileName = gdaiDatafileVo.getName();
    String datasetCephPath = gdaiDatafileVo.getDatasetCephPath();
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("文件名称不能为空");
    }
    if (StringUtils.isBlank(datasetCephPath)) {
        return RestResult.genFailResult("存放路径不能为空");
    }
    try {
        //拼装文件完整路径
        String filePath = datasetCephPath + breakpointPath + "/" + fileName;
        String confFilePath = datasetCephPath + breakpointConfPath + "/" + fileName + ".conf";
        if (StringUtils.isNotBlank(filePath)) {
            File file = FileUtils.getFile(filePath);
            if (file.exists()) {
                FileUtil.deleteFile(file);
            }
        }
        if (StringUtils.isNotBlank(confFilePath)) {
            File confFile = FileUtils.getFile(confFilePath);
            if (confFile.exists()) {
                FileUtil.deleteFile(confFile);
            }
        }
    } catch (Exception e) {
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量
/**
 * 断点续传文件目录
 */
@Value("${cephUpload.breakpointPath}")
private String breakpointPath;
/**
 * 断点续传conf文件目录
 */
@Value("${cephUpload.breakpointConfPath}")
private String breakpointConfPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为saveDataFileInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult saveDataFileInfo(GdaiDatafileVo gdaiDatafileVo) {
    log.info("GdaiDatafileServiceImpl.saveDataFileInfo params: " + JSON.toJSONString(gdaiDatafileVo));
    Long datasetId = gdaiDatafileVo.getDatasetId();
    String markStatus = gdaiDatafileVo.getMarkStatus();
    String dataType = gdaiDatafileVo.getDataType();
    String datasetCephPath = gdaiDatafileVo.getDatasetCephPath();
    String fileName = gdaiDatafileVo.getName();
    if (datasetId == null) {
        return RestResult.genFailResult("所属数据集ID不能为空");
    }
    if (StringUtils.isBlank(markStatus)) {
        return RestResult.genFailResult("有无标注信息不能为空");
    }
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    if (StringUtils.isBlank(datasetCephPath)) {
        return RestResult.genFailResult("存放路径不能为空");
    }
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("压缩包名称不能为空");
    }
    try {
        //获取登录用户信息
        User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
        Long userId = user.getId();
        log.info("用户ID: [{}]", userId);
        //拼装上传压缩包目录
        String filePath = datasetCephPath + breakpointPath;
        String confFilePath = datasetCephPath + breakpointConfPath;
        //另起线程处理压缩包数据
        //            GdaiDatafileServiceImpl gdaiDatafileServiceImpl = new GdaiDatafileServiceImpl();
        //            uploadThreadPool.execute(new GdaiDatafileServiceImpl.StartSaveDataFileInfo(transactionManager, transactionStatuses, gdaiDatafileMapper, gdaiDatalabelMapper,
        //                    gdaiDatafileLabelMapper, gdaiDatasetMapper, gdaiDatafileServiceImpl, datasetId, markStatus, dataType, datasetCephPath, scale, userId, filePath, confFilePath, fileName));
        gdaiDatafileVo.setCreatorId(userId);
        gdaiDatafileVo.setFilePath(filePath);
        gdaiDatafileVo.setConfFilePath(confFilePath);
        gdaiDatafileAsyncTask.startSaveDataFileInfo(gdaiDatafileVo);
    } catch (Exception e) {
        log.info("保存上传数据异常", e);
    }
    return RestResult.genSuccessResult("保存成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.Map
### 类级别的变量
/**
 * 断点续传文件目录
 */
@Value("${cephUpload.breakpointPath}")
private String breakpointPath;
/**
 * 断点续传conf文件目录
 */
@Value("${cephUpload.breakpointConfPath}")
private String breakpointConfPath;
/**
 * 图片压缩比例
 */
@Value("${file.scale}")
private String scale;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileService gdaiDatafileService;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Autowired
private HttpServletRequest request;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
@Resource
private PlatformTransactionManager transactionManager;
List<TransactionStatus> transactionStatuses = Collections.synchronizedList(new ArrayList<>());
@Resource
private GdaiDatafileAsyncTask gdaiDatafileAsyncTask;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryFileById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    }
public RestResult<GdaiDatafileVo> queryFileById(GdaiDatafileVo datafileVo) throws TrainginCenterException {
    log.info("GdaiDatafileServiceImpl.queryFileById params: " + JSON.toJSONString(datafileVo));
    if (datafileVo == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    Long datasetId = datafileVo.getDatasetId();
    Long datafileId = datafileVo.getDatafileId();
    String dataType = datafileVo.getDataType();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (datafileId == null) {
        return RestResult.genFailResult("文件ID不能为空");
    }
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatafile gdaiDatafile = checkGdaiDatafile(user, datafileId);
    String iconUrl = gdaiDatafile.getIconUrl();
    String cephUrl = gdaiDatafile.getCephUrl();
    GdaiDatafileVo gdaiDatafileVo = new GdaiDatafileVo();
    try {
        //根据datafileId和datasetId查询该数据集下所有标注坐标
        List<GdaiDatafileLabelVo> gdaiDatafileLabelVos = gdaiDatafileLabelMapper.queryLabelAndOther(new GdaiDatafileLabel(datasetId, datafileId));
        gdaiDatafileVo.setFileLabels(gdaiDatafileLabelVos);
        //图片才需要生成base64，视频不需要
        if (!"video".equalsIgnoreCase(dataType)) {
            if (StringUtils.isNotBlank(iconUrl)) {
                //根据cephUrl下载对应文件流并转换为base64
                if (StringUtils.isNotBlank(cephUrl)) {
                    String base64 = FileUtil.getFileStream2Base64(cephUrl);
                    gdaiDatafileVo.setCephBase64(base64);
                }
            }
        }
        BeanUtils.copyProperties(gdaiDatafile, gdaiDatafileVo);
    } catch (Exception e) {
        log.info("根据文件ID查询文件信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiDatafileVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryTempFileById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<GdaiDatafileVo> queryTempFileById(GdaiDatafileVo datafileVo) throws TrainginCenterException {
    log.info("GdaiDatafileServiceImpl.queryTempFileById params: " + JSON.toJSONString(datafileVo));
    if (datafileVo == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    Long datasetId = datafileVo.getDatasetId();
    Long datafileId = datafileVo.getDatafileId();
    String dataType = datafileVo.getDataType();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (datafileId == null) {
        return RestResult.genFailResult("文件ID不能为空");
    }
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    checkRoleGdaiDatafile(user, datafileId);
    GdaiDatafileVo gdaiDatafileVo = new GdaiDatafileVo();
    try {
        //根据datafileId和datasetId查询该数据集下所有标注坐标
        List<GdaiDatafileLabelVo> gdaiDatafileLabelVo = gdaiDatafileLabelTempMapper.queryTempLabelAndOther(new GdaiDatafileLabel(datasetId, datafileId));
        List<GdaiDatafileVo> gdaiDatafileVoList = gdaiDatafileMapper.queryFileInfoById(datafileId);
        if (gdaiDatafileVoList != null && gdaiDatafileVoList.size() > 0) {
            GdaiDatafileVo gdaiDatafileVo1 = gdaiDatafileVoList.get(0);
            BeanUtils.copyProperties(gdaiDatafileVo1, gdaiDatafileVo);
            if (!"video".equalsIgnoreCase(dataType)) {
                //根据cephUrl下载对应文件流并转换为base64，图片需要，视频不需要
                if (StringUtils.isNotBlank(gdaiDatafileVo1.getCephUrl())) {
                    String base64 = FileUtil.getFileStream2Base64(gdaiDatafileVo1.getCephUrl());
                    gdaiDatafileVo.setCephBase64(base64);
                }
            }
        }
        gdaiDatafileVo.setFileLabels(gdaiDatafileLabelVo);
    } catch (Exception e) {
        log.info("根据文件ID查询文件信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiDatafileVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryCountById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<GdaiDatafileVo> queryCountById(Long id) throws TrainginCenterException {
    log.info("GdaiDatafileServiceImpl.queryCountById params: {}", id);
    if (id == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    gdaiDatasetServiceImpl.checkRoleGdaiDataset(user, id);
    GdaiDatafileVo datafileVo = new GdaiDatafileVo();
    try {
        List<String> allList = new ArrayList<>();
        allList.add("1");
        allList.add("2");
        allList.add("3");
        int allNum = gdaiDatafileMapper.queryAllFileNum(id, allList);
        List<String> hasMarkList = new ArrayList<>();
        hasMarkList.add("2");
        hasMarkList.add("3");
        int hasMarkNum = gdaiDatafileMapper.queryAllFileNum(id, hasMarkList);
        List<String> noMarkList = new ArrayList<>();
        noMarkList.add("1");
        int noMarkNum = gdaiDatafileMapper.queryAllFileNum(id, noMarkList);
        int confirmStatusNum = gdaiDatafileMapper.queryConfirmStatus(id, "0");
        datafileVo.setAllNum(allNum);
        datafileVo.setHasMarkNum(hasMarkNum);
        datafileVo.setNoMarkNum(noMarkNum);
        datafileVo.setConfirmStatusNum(confirmStatusNum);
    } catch (Exception e) {
        log.info("根据数据集ID查询文件数量异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(datafileVo);
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.io.File
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Autowired
private HttpServletRequest request;
@Autowired
private GdaiDatasetServiceImpl gdaiDatasetServiceImpl;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为uploadTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult uploadTxt(GdaiDatafileVo datafileVo) {
    log.info("GdaiDatafileServiceImpl.uploadTxt");
    List<MultipartFile> files = datafileVo.getFiles();
    Long datasetId = datafileVo.getDatasetId();
    String markStatus = datafileVo.getMarkStatus();
    String datasetCephPath = datafileVo.getDatasetCephPath();
    if (files == null) {
        return RestResult.genFailResult("上传文件不能为空");
    }
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (StringUtils.isBlank(markStatus)) {
        return RestResult.genFailResult("有无标注信息不能为空");
    }
    if (StringUtils.isBlank(datasetCephPath)) {
        return RestResult.genFailResult("存放路径不能为空");
    }
    List<GdaiDatafile> fileList = new ArrayList<>();
    GdaiDatafile gdaiDatafile;
    File destPath;
    String uploadPath;
    try {
        long startTime = System.currentTimeMillis();
        for (MultipartFile multipartFile : files) {
            //获取文件名称
            String fileName = multipartFile.getOriginalFilename();
            //校验上传文本类型
            boolean validTextFile = FileUtil.isValidTextFile(fileName);
            if (!validTextFile) {
                return RestResult.genFailResult("上传文本必须为txt类型");
            }
            //获取文件大小
            long size = multipartFile.getSize();
            //获取当前数据集文件存储路径
            destPath = FileUtils.getFile(datasetCephPath);
            uploadPath = destPath + "/source/";
            if (!(FileUtils.getFile(uploadPath)).exists()) {
                FileUtil.createDir(uploadPath);
            }
            //上传文件到项目临时目录
            File tempPath = FileUtils.getFile(uploadPath + fileName);
            multipartFile.transferTo(tempPath);
            //对临时文件进行重命名
            String[] split = fileName.split("\\.");
            String newFileName = UuidUtils.uuid() + "." + split[1];
            String oldPath = uploadPath + fileName;
            String newPath = uploadPath + newFileName;
            FileUtils.getFile(oldPath).renameTo(FileUtils.getFile(newPath));
            //读取临时文件下txt文件中指定长度字符
            String shortText = FileUtil.readTxt(newPath);
            gdaiDatafile = new GdaiDatafile();
            gdaiDatafile.setDatasetId(datasetId);
            gdaiDatafile.setFileName(newFileName);
            gdaiDatafile.setCephUrl(newPath);
            gdaiDatafile.setFileSize(size);
            gdaiDatafile.setConfirmStatus("1");
            gdaiDatafile.setMarkStatus(markStatus);
            gdaiDatafile.setRemarks(fileName);
            gdaiDatafile.setShortText(shortText);
            //解决字段非空约束,默认赋值为空
            gdaiDatafile.setIconUrl(" ");
            gdaiDatafile.setScreenH(0);
            gdaiDatafile.setScreenW(0);
            gdaiDatafile.setFileData(" ");
            fileList.add(gdaiDatafile);
        }
        //批量新增文件信息入库
        addBatch(fileList);
        //全部导入完毕修改新数据集导入状态为已完成-S0I
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setImpStatus("S0I");
        set.setModifyTime(new Date());
        gdaiDatasetMapper.updateById(set);
        long endTime = System.currentTimeMillis();
        float excTime = (float) (endTime - startTime) / 1000;
        log.info("导入文本完毕，总耗时：" + excTime + "秒");
    } catch (Exception e) {
        log.info("导入文本异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        //新数据集导入异常修改状态为导入失败-S0F
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setImpStatus("S0F");
        set.setModifyTime(new Date());
        gdaiDatasetMapper.updateById(set);
        return RestResult.genFailResult("导入文本异常");
    }
    return RestResult.genSuccessResult("导入文本成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.vo.Result
com.google.common.io.Files
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.ArrayList
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryTextInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTextInfo(GdaiDatafileVo datafileVo) {
    log.info("GdaiDatafileServiceImpl.queryTextInfo params: " + JSON.toJSONString(datafileVo));
    if (datafileVo == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    Page<GdaiDatafile> gdaiDatafile = null;
    UiPage<GdaiDatafileVo> uiPage;
    List<GdaiDatafileVo> gdaiDatafiles = null;
    try {
        if (StringUtils.isNotBlank(datafileVo.getMarkStatus())) {
            List<String> list = new ArrayList<>();
            if ("1".equals(datafileVo.getMarkStatus())) {
                //查询无标注文本信息
                list.add("1");
            } else if ("2".equals(datafileVo.getMarkStatus())) {
                //查询有标注文本信息
                list.add("2");
                list.add("3");
            } else if ("4".equals(datafileVo.getMarkStatus())) {
                //查询全部文本信息
                list.add("1");
                list.add("2");
                list.add("3");
            } else {
                return RestResult.genFailResult("标注类型参数错误");
            }
            datafileVo.setMarkStatusList(list);
            PageHelper.startPage(datafileVo.getPageNumber(), datafileVo.getPageCount());
            gdaiDatafiles = gdaiDatafileMapper.queryTextInfoById(datafileVo);
        }
        if (StringUtils.isNotBlank(datafileVo.getConfirmStatus())) {
            //gdaiDatafile = gdaiDatafileService.selectPage(new Page<>(datafileVo.getPageNumber(), datafileVo.getPageCount()), new EntityWrapper<GdaiDatafile>().eq("dataset_id", datafileVo.getDatasetId()).eq("confirm_status", datafileVo.getConfirmStatus()));
            PageHelper.startPage(datafileVo.getPageNumber(), datafileVo.getPageCount());
            gdaiDatafiles = gdaiDatafileMapper.queryTextInfoById(datafileVo);
        }
        //总条数
        int total = PageHelper.getTotal();
        //每页条数
        int pageSize = datafileVo.getPageCount();
        //当前页数
        int pageNum = datafileVo.getPageNumber();
        //总页数
        int pages = 0;
        if (total > 0 && pageSize > 0) {
            pages = (total + pageSize - 1) / pageSize;
        }
        uiPage = new UiPage<>();
        uiPage.setPageSize(pageSize);
        uiPage.setPageNum(pageNum);
        uiPage.setTotal(total);
        uiPage.setPages(pages);
        uiPage.setList(gdaiDatafiles);
        if (gdaiDatafile != null) {
            uiPage = ReturnJson.turnUiPage(gdaiDatafile);
        }
    } catch (Exception e) {
        log.info("查询文件信息异常", e);
        return RestResult.genFailResult("查询异常");
    } finally {
        PageHelper.remove();
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.plugins.pagination.PageHelper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.ReturnJson
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileService gdaiDatafileService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryMarkInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryMarkInfo(GdaiDatafileVo datafileVo) {
    log.info("GdaiDatafileServiceImpl.queryMarkInfo params: " + JSON.toJSONString(datafileVo));
    if (datafileVo == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    Page<GdaiDatafile> gdaiDatafile = null;
    UiPage<GdaiDatafileVo> uiPage;
    List<GdaiDatafileVo> gdaiDatafiles = null;
    try {
        if (StringUtils.isNotBlank(datafileVo.getMarkStatus())) {
            List<String> list = new ArrayList<>();
            if ("1".equals(datafileVo.getMarkStatus())) {
                //查询无标注文本信息
                list.add("1");
            } else if ("2".equals(datafileVo.getMarkStatus())) {
                //查询有标注文本信息
                list.add("2");
                list.add("3");
            } else if ("4".equals(datafileVo.getMarkStatus())) {
                //查询全部文本信息
                list.add("1");
                list.add("2");
                list.add("3");
            } else {
                return RestResult.genFailResult("标注类型参数错误");
            }
            datafileVo.setMarkStatusList(list);
            PageHelper.startPage(datafileVo.getPageNumber(), datafileVo.getPageCount());
            gdaiDatafiles = gdaiDatafileMapper.queryTextInfoById(datafileVo);
            if (gdaiDatafiles != null && gdaiDatafiles.size() > 0) {
                GdaiDatafileVo gdaiDatafileVo = gdaiDatafiles.get(0);
                String cephUrl = gdaiDatafileVo.getCephUrl();
                if (StringUtils.isNotBlank(cephUrl)) {
                    //调用封装方法，从ceph上下载该txt文件读取文本信息
                    StringBuilder sb = readFromCeph(cephUrl);
                    gdaiDatafileVo.setShortText(sb.toString());
                }
            }
        }
        if (StringUtils.isNotBlank(datafileVo.getConfirmStatus())) {
            //gdaiDatafile = gdaiDatafileService.selectPage(new Page<>(datafileVo.getPageNumber(), datafileVo.getPageCount()), new EntityWrapper<GdaiDatafile>().eq("dataset_id", datafileVo.getDatasetId()).eq("confirm_status", datafileVo.getConfirmStatus()));
            PageHelper.startPage(datafileVo.getPageNumber(), datafileVo.getPageCount());
            gdaiDatafiles = gdaiDatafileMapper.queryTextInfoById(datafileVo);
        }
        //总条数
        int total = PageHelper.getTotal();
        //每页条数
        int pageSize = datafileVo.getPageCount();
        //当前页数
        int pageNum = datafileVo.getPageNumber();
        //总页数
        int pages = 0;
        if (total > 0 && pageSize > 0) {
            pages = (total + pageSize - 1) / pageSize;
        }
        uiPage = new UiPage<>();
        uiPage.setPageSize(pageSize);
        uiPage.setPageNum(pageNum);
        uiPage.setTotal(total);
        uiPage.setPages(pages);
        uiPage.setList(gdaiDatafiles);
        if (gdaiDatafile != null) {
            uiPage = ReturnJson.turnUiPage(gdaiDatafile);
        }
    } catch (Exception e) {
        log.info("查询文件信息异常", e);
        return RestResult.genFailResult("查询异常");
    } finally {
        PageHelper.remove();
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.plugins.pagination.PageHelper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.ReturnJson
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileService gdaiDatafileService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryLabelInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryLabelInfo(GdaiDatalabel gdaiDatalabel) {
    log.info("GdaiDatafileServiceImpl.queryLabelInfo params: " + JSON.toJSONString(gdaiDatalabel));
    if (gdaiDatalabel == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    if (gdaiDatalabel.getDatasetId() == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    List<GdaiDatafileLabelVo> gdaiDatafileLabelVos;
    try {
        //根据数据集ID查询文本对应的标签和数量
        gdaiDatafileLabelVos = gdaiDatalabelMapper.queryLabelInfo(gdaiDatalabel);
    } catch (Exception e) {
        log.info("查询文件信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiDatafileLabelVos);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryFullText的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<GdaiDatafile> queryFullText(GdaiDatafile gdaiDatafile) {
    log.info("GdaiDatafileServiceImpl.queryFullText params: " + JSON.toJSONString(gdaiDatafile));
    if (gdaiDatafile == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    StringBuilder sb = null;
    InputStream inputStream = null;
    try {
        String cephUrl = gdaiDatafile.getCephUrl();
        if (StringUtils.isNotBlank(cephUrl)) {
            //从ceph上下载该txt文件读取文本信息
            sb = new StringBuilder();
            inputStream = FileUtil.readStreamObject(cephUrl);
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
            String len;
            while ((len = br.readLine()) != null) {
                sb.append(len);
            }
        }
        gdaiDatafile.setShortText(sb == null ? "" : sb.toString());
    } catch (Exception e) {
        log.info("根据文本ID查询文本信息异常", e);
        return RestResult.genFailResult("查询异常");
    } finally {
        try {
            if (inputStream != null) {
                inputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return RestResult.genSuccessResult(gdaiDatafile);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.BufferedReader
java.io.File
java.io.IOException
java.io.InputStream
java.io.InputStreamReader
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为deleteText的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteText(List<GdaiDatafile> list) {
    log.info("GdaiDatafileServiceImpl.deleteText params: " + JSON.toJSONString(list));
    if (list == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    List<GdaiDatafileLabel> labelList = new ArrayList<>();
    GdaiDatafileLabel gdaiDatafileLabel;
    try {
        //删除文件信息
        //            gdaiDatafileMapper.deleteBatch(list);
        gdaiDatafileMapper.deleteBatchV1(list);
        for (GdaiDatafile file : list) {
            gdaiDatafileLabel = new GdaiDatafileLabel();
            gdaiDatafileLabel.setDatasetId(file.getDatasetId());
            gdaiDatafileLabel.setDatafileId(file.getDatafileId());
            labelList.add(gdaiDatafileLabel);
        }
        //删除该文件对应的坐标信息
        gdaiDatafileLabelMapper.deleteBatch(labelList);
        //删除cephfs上该文本的信息，删除之前需确定该文本已经没有其他数据集使用才能删除
        boolean bo1 = false;
        boolean bo2 = false;
        for (GdaiDatafile file : list) {
            int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("file_name", file.getFileName()));
            if (fileCount == 0) {
                if (StringUtils.isNotBlank(file.getCephUrl())) {
                    //根据文件名称查询所有数据集下是否还有存在，如果不存在则删除cephfs上该文本的信息
                    bo1 = FileUtil.deleteFile(file.getCephUrl());
                    //删除对应的json标注文件
                    String[] split = file.getFileName().split("\\.");
                    String jsonUrl = file.getCephUrl().replace(split[1], "json");
                    bo2 = FileUtil.deleteFile(jsonUrl);
                }
                if (!bo1 || !bo2) {
                    log.info("删除失败");
                }
            }
        }
    } catch (Exception e) {
        log.info("删除文件信息异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为generateFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult generateFile(GdaiDatafileVo gdaiDatafileVo) {
    log.info("GdaiDatafileServiceImpl.generateFile params: " + JSON.toJSONString(gdaiDatafileVo));
    if (gdaiDatafileVo == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    if (gdaiDatafileVo.getDatasetId() == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (gdaiDatafileVo.getDatafileId() == null) {
        return RestResult.genFailResult("文件ID不能为空");
    }
    //        if (gdaiDatafileVo.getDataType() == null) {
    //            return RestResult.genFailResult("数据集类型不能为空");
    //        }
    if (gdaiDatafileVo.getLabelMap() == null) {
        return RestResult.genFailResult("标签集合不能为空");
    }
    try {
        //根据数据集ID和文件ID查询该数据集下包含的所有文件信息
        GdaiDatafile datafile = gdaiDatafileMapper.selectById(gdaiDatafileVo.getDatafileId());
        if (datafile != null) {
            Long datasetId = datafile.getDatasetId();
            Long datafileId = datafile.getDatafileId();
            String fileName = datafile.getFileName();
            String cephUrl = datafile.getCephUrl();
            String[] split = datafile.getFileName().split("\\.");
            String jsonName = split[0] + ".json";
            String txtName = split[0] + ".txt";
            String labelDictionaryName = "labelDictionary.txt";
            //jsonPath为生成的json文件存放位置
            String jsonPath = datafile.getCephUrl().replace(datafile.getFileName(), jsonName);
            //根据数据集ID反查出将来图片和坐标文件存放目录，将图片存放在files下面，生成的坐标文件放在labels目录下
            GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
            String filesPath = dataset.getDatasetFilePath();
            String labelsPath = dataset.getDatasetLabelPath();
            String labelDictionaryPath = dataset.getDatasetCephPath();
            //将文件拷贝到新目录
            Files.copy(FileUtils.getFile(cephUrl), FileUtils.getFile(filesPath + fileName));
            //根据数据集ID和文件ID查询查询该文件对应的坐标信息
            GdaiDatafileLabelVo gdaiDatafileLabelVo = new GdaiDatafileLabelVo();
            gdaiDatafileLabelVo.setDatasetId(datasetId);
            gdaiDatafileLabelVo.setDatafileId(datafileId);
            List<GdaiDatafileLabelVo> gdaiDatafileLabelVos = gdaiDatafileLabelMapper.queryLabelAndOther(gdaiDatafileLabelVo);
            if (gdaiDatafileLabelVos == null || gdaiDatafileLabelVos.size() == 0) {
                gdaiDatafileLabelVos = gdaiDatafileLabelTempMapper.queryTempLabelAndOther(gdaiDatafileLabelVo);
            }
            JSONObject jsonObj = new JSONObject();
            StringBuilder sb = new StringBuilder();
            JSONArray array = new JSONArray();
            if (gdaiDatafileLabelVos != null && gdaiDatafileLabelVos.size() > 0) {
                for (GdaiDatafileLabelVo vo : gdaiDatafileLabelVos) {
                    //根据labelName查询对应下标值
                    String labelName = vo.getLabelName();
                    //前台传过来的标签顺序
                    Map<String, String> labelMap = gdaiDatafileVo.getLabelMap();
                    String index = labelMap.get(labelName);
                    //根据annotation_type和annotation_template把label_data转换成对应的模型
                    BaseModel model = ModelUtil.createModel(dataset.getAnnotationType(), dataset.getAnnotationTemplate(), vo.getLabelData());
                    if (model == null) {
                        return RestResult.genFailResult("数据集类型错误");
                    }
                    sb.append(model.generateTxt(index));
                    array.add(model.generateJson(index));
                    jsonObj.put("labels", array);
                }
                //log.info(jsonPath + "===" + jsonObj);
                //生成字典文件
                Map<String, String> labelMap = gdaiDatafileVo.getLabelMap();
                Object obj = JSONArray.toJSON(labelMap);
                String labelJson = obj.toString();
                boolean labelFile = FileUtil.createFile(labelJson, labelDictionaryPath + "/datasets/dictionary/" + labelDictionaryName);
                //生成JSON文件
                boolean jsonFile = FileUtil.createFile(jsonObj.toJSONString(), jsonPath);
                boolean txtFile = FileUtil.createFile(sb.toString(), labelsPath + txtName);
                if (!jsonFile && !txtFile && !labelFile) {
                    return RestResult.genFailResult("生成失败");
                }
            }
        }
    } catch (Exception e) {
        log.info("生成文件异常", e);
        return RestResult.genFailResult("生成异常");
    }
    return RestResult.genSuccessResult("生成成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.model.BaseModel
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.ModelUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.Result
com.google.common.io.Files
org.apache.commons.io.FileUtils
org.springframework.stereotype.Service
java.io.File
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为generateFileBatch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult generateFileBatch(GdaiDatafileVo gdaiDatafileVo) {
    try {
        List<GdaiDatafile> gdaiDatafileList = gdaiDatafileMapper.selectList(new EntityWrapper<GdaiDatafile>().eq("dataset_id", gdaiDatafileVo.getDatasetId()));
        for (GdaiDatafile datafile : gdaiDatafileList) {
            if (Objects.equals(datafile.getMarkStatus(), "2")) {
                //{"datasetId":539,"datafileId":8829,"labelMap":{"衣服":"0","裤子":"1"}}
                GdaiDatafileVo datafileVo = new GdaiDatafileVo();
                datafileVo.setDatasetId(datafile.getDatasetId());
                datafileVo.setDatafileId(datafile.getDatafileId());
                datafileVo.setLabelMap(gdaiDatafileVo.getLabelMap());
                generateFile(datafileVo);
            }
        }
        return RestResult.genSuccessResult("生成成功");
    } catch (Exception e) {
        log.info("生成文件异常", e);
        return RestResult.genFailResult("生成异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
com.eshore.gdai.trainingcenter.vo.Result
java.io.File
java.util.List
java.util.Map
java.util.Objects
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为uploadVideo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult uploadVideo(GdaiDatafileVo gdaiDatafileVo) {
    log.info("GdaiDatafileServiceImpl.uploadVideo");
    List<MultipartFile> files = gdaiDatafileVo.getFiles();
    Long datasetId = gdaiDatafileVo.getDatasetId();
    String markStatus = gdaiDatafileVo.getMarkStatus();
    String datasetCephPath = gdaiDatafileVo.getDatasetCephPath();
    if (files == null) {
        return RestResult.genFailResult("上传文件不能为空");
    }
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (StringUtils.isBlank(markStatus)) {
        return RestResult.genFailResult("有无标注信息不能为空");
    }
    if (StringUtils.isBlank(datasetCephPath)) {
        return RestResult.genFailResult("存放路径不能为空");
    }
    List<GdaiDatafile> fileList = new ArrayList<>();
    File destPath;
    String uploadPath;
    try {
        long startTime = System.currentTimeMillis();
        GdaiDatafile gdaiDatafile;
        for (MultipartFile next : files) {
            //获取文件大小
            long size = next.getSize();
            //获取文件名称
            String originalFilename = next.getOriginalFilename();
            //校验上传视频类型
            boolean validImageExtension = FileUtil.isValidVideoExtension(originalFilename);
            if (!validImageExtension) {
                return RestResult.genFailResult("上传视频必须为mp4类型");
            }
            //获取当前数据集文件存储路径
            destPath = FileUtils.getFile(datasetCephPath);
            uploadPath = destPath + "/source/";
            if (!(FileUtils.getFile(uploadPath)).exists()) {
                FileUtil.createDir(uploadPath);
            }
            String sourcePath = uploadPath + originalFilename;
            //上传文件到指定目录
            File tempPath = FileUtils.getFile(sourcePath);
            next.transferTo(tempPath);
            //对即将转码的文件进行重命名
            String[] split = originalFilename.split("\\.");
            String uuid = UuidUtils.uuid();
            String newFileName = uuid + "." + split[1];
            String newPath = uploadPath + newFileName;
            //对视频文件进行统一转码处理
            VideoEncodeUtil.VideoEncode(sourcePath, newPath);
            //转码完成删除源文件
            FileUtil.deleteFile(sourcePath);
            //创建微缩图存储路径（包含微缩图名称）
            String iconFileName = uuid + ".jpg";
            String iconName = "thumb_" + iconFileName;
            String path = datasetCephPath + "/thumb/";
            if (!(FileUtils.getFile(path)).exists()) {
                FileUtil.createDir(path);
            }
            //调用封装方法，获取原始视频信息并生产微缩图
            Map<String, String> videoMap = generateThumbnail(newPath, path + iconName, 1);
            if (videoMap == null) {
                return RestResult.genFailResult("获取上传视频文件信息失败");
            }
            //拼装获取的视频文件信息为JSON字符串，最终放入到fileData字段
            String videoString = JSON.toJSONString(videoMap);
            gdaiDatafile = new GdaiDatafile();
            gdaiDatafile.setDatasetId(datasetId);
            gdaiDatafile.setFileName(newFileName);
            gdaiDatafile.setCephUrl(newPath);
            gdaiDatafile.setIconUrl(path + iconName);
            gdaiDatafile.setFileSize(size);
            gdaiDatafile.setScreenH(Integer.parseInt(videoMap.get("originalWidth")));
            gdaiDatafile.setScreenW(Integer.parseInt(videoMap.get("originalHeight")));
            gdaiDatafile.setConfirmStatus("1");
            gdaiDatafile.setMarkStatus(markStatus);
            gdaiDatafile.setFileData(videoString);
            gdaiDatafile.setRemarks(originalFilename);
            //解决字段非空约束,默认赋值为空
            gdaiDatafile.setShortText(" ");
            fileList.add(gdaiDatafile);
        }
        //批量新增文件信息入库
        addBatch(fileList);
        //全部导入完毕修改新数据集导入状态为已完成-S0I
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setImpStatus("S0I");
        set.setModifyTime(new Date());
        gdaiDatasetMapper.updateById(set);
        long endTime = System.currentTimeMillis();
        float excTime = (float) (endTime - startTime) / 1000;
        log.info("导入视频完毕，总耗时：" + excTime + "秒");
    } catch (Exception e) {
        log.info("导入视频异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        //新数据集导入异常修改状态为导入失败-S0F
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setImpStatus("S0F");
        set.setModifyTime(new Date());
        gdaiDatasetMapper.updateById(set);
        return RestResult.genFailResult("导入视频异常");
    }
    return RestResult.genSuccessResult("视频导入成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.util.VideoEncodeUtil
com.eshore.gdai.trainingcenter.vo.Result
com.google.common.io.Files
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.ArrayList
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为queryVideoFileById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryVideoFileById(Long datasetId, Long datafileId, HttpServletResponse response) throws Exception {
    log.info("GdaiDatafileServiceImpl.queryVideoFileById params:[{}],[{}] ", datasetId, datafileId);
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (datafileId == null) {
        return RestResult.genFailResult("文件ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatafile gdaiDatafile = checkGdaiDatafile(user, datafileId);
    //获取视频存放URL
    String cephUrl = gdaiDatafile.getCephUrl();
    RandomAccessFile targetFile = null;
    OutputStream outputStream = null;
    try {
        outputStream = response.getOutputStream();
        response.reset();
        //获取请求头中Range的值
        String rangeString = request.getHeader("Range");
        //打开文件
        File file = new File(cephUrl);
        if (file.exists()) {
            //使用RandomAccessFile读取文件
            targetFile = new RandomAccessFile(file, "r");
            long fileLength = targetFile.length();
            long requestSize = (int) fileLength;
            //分段加载视频
            //从Range中提取需要获取数据的开始和结束位置
            long requestStart = 0, requestEnd = file.length() - 1;
            if (rangeString != null) {
                String[] ranges = rangeString.split("=");
                if (ranges.length > 1) {
                    String[] rangeDatas = ranges[1].split("-");
                    requestStart = Integer.parseInt(rangeDatas[0]);
                    if (rangeDatas.length > 1) {
                        requestEnd = Integer.parseInt(rangeDatas[1]);
                    }
                }
            }
            if (requestEnd != 0 && requestEnd > requestStart) {
                requestSize = requestEnd - requestStart + 1;
            }
            //根据协议设置请求头
            response.setHeader(HttpHeaders.ACCEPT_RANGES, "bytes");
            response.setHeader(HttpHeaders.CONTENT_TYPE, "video/mp4");
            if (rangeString == null) {
                response.setHeader(HttpHeaders.CONTENT_LENGTH, fileLength + "");
            } else {
                long length;
                if (requestEnd > 0) {
                    length = requestEnd - requestStart + 1;
                    response.setHeader(HttpHeaders.CONTENT_LENGTH, "" + length);
                    response.setHeader(HttpHeaders.CONTENT_RANGE, "bytes " + requestStart + "-" + requestEnd + "/" + fileLength);
                } else {
                    length = fileLength - requestStart;
                    response.setHeader(HttpHeaders.CONTENT_LENGTH, "" + length);
                    response.setHeader(HttpHeaders.CONTENT_RANGE, "bytes " + requestStart + "-" + (fileLength - 1) + "/" + fileLength);
                }
            }
            //成功加载视频返回206
            response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
            //设置targetFile，从自定义位置开始读取数据
            targetFile.seek(requestStart);
            //从磁盘读取数据流返回
            byte[] cache = new byte[4096];
            try {
                while (requestSize > 0) {
                    int len = targetFile.read(cache);
                    if (requestSize < cache.length) {
                        outputStream.write(cache, 0, (int) requestSize);
                    } else {
                        outputStream.write(cache, 0, len);
                        if (len < cache.length) {
                            break;
                        }
                    }
                    requestSize -= cache.length;
                }
            } catch (IOException e) {
                log.info("读取视频文件流异常", e);
                return RestResult.genFailResult("读取视频文件异常");
            }
        } else {
            return RestResult.genFailResult("视频文件路径有误");
        }
        outputStream.flush();
    } catch (Exception e) {
        log.info("获取视频文件异常", e);
        return RestResult.genFailResult("获取视频文件异常");
    } finally {
        if (outputStream != null) {
            try {
                outputStream.close();
            } catch (IOException e) {
                log.info("关闭流异常", e);
            }
        }
        if (targetFile != null) {
            try {
                targetFile.close();
            } catch (IOException e) {
                log.info("关闭流异常", e);
            }
        }
    }
    return RestResult.genSuccessResult("查询成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.service.GdaiDatafileService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.http.HttpHeaders
org.springframework.stereotype.Service
javax.servlet.http.HttpServletResponse
java.io.File
java.io.IOException
java.io.OutputStream
java.io.RandomAccessFile
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为generateCsvFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult generateCsvFile(Map<String, Object> paraMap) {
    String datasetId = (String) paraMap.get("datasetId");
    if (StringUtils.isEmpty(datasetId)) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    String filePath = (String) paraMap.get("filePath");
    if (StringUtils.isEmpty(filePath)) {
        return RestResult.genFailResult("文件路径不能为空");
    }
    Map context = (Map) paraMap.get("context");
    if (context == null && context.size() <= 0) {
        return RestResult.genFailResult("context不能为空");
    }
    String type = (String) context.get("type");
    if (StringUtils.isEmpty(type)) {
        return RestResult.genFailResult("转换标签类型不能为空");
    }
    String headerStr = (String) context.get("header");
    GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
    if (dataset == null) {
        return RestResult.genFailResult("数据集ID不存在");
    }
    String annotationType = dataset.getAnnotationType();
    String annotationTemplate = dataset.getAnnotationTemplate();
    //已标注列表
    List<String[]> labeledDataList = new ArrayList<>();
    //未标注列表
    List<String[]> unLabeledDataList = new ArrayList<>();
    //csv内容
    List<GdaiDatafile> gdaiDatafileList = gdaiDatafileMapper.selectList(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId));
    if (Objects.equals(annotationType.toLowerCase(), "imgcls".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "imgcls".toLowerCase())) {
        //图像分类-单图单标签
        //一对一
        if (StringUtils.isEmpty(headerStr)) {
            headerStr = "image,label";
        }
        //csv头
        String[] header = headerStr.split(",");
        labeledDataList.add(header);
        unLabeledDataList.add(header);
        String imagePath = (String) context.get("imagePath");
        if (StringUtils.isEmpty(imagePath)) {
            imagePath = "/trainDataset/file";
        }
        for (GdaiDatafile datafile : gdaiDatafileList) {
            //文件名,标签序号
            String[] data = new String[2];
            data[0] = imagePath + "/" + datafile.getFileName();
            data[1] = "";
            List<GdaiDatafileLabelVo> datafileLabelVos = gdaiDatafileLabelMapper.queryLabels(datafile.getDatafileId());
            if (datafileLabelVos != null && datafileLabelVos.size() > 0) {
                BaseModel model = ModelUtil.createModel(dataset.getAnnotationType(), dataset.getAnnotationTemplate(), datafileLabelVos.get(0).getLabelData());
                if (model == null) {
                    return RestResult.genFailResult("数据集类型错误");
                }
                data[1] = (String) model.generateLabel(type);
                labeledDataList.add(data);
            } else {
                unLabeledDataList.add(data);
            }
        }
    } else if (Objects.equals(annotationType.toLowerCase(), "TxtEntity".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "TxtEntity".toLowerCase())) {
        //文本实体抽取
        //一对多
        if (StringUtils.isEmpty(headerStr)) {
            headerStr = "text_snippet,entity_annotations";
        }
        //csv头
        String[] header = headerStr.split(",");
        labeledDataList.add(header);
        String unLabeledHeaderStr = "text_snippet,id";
        String[] unLabeledHeader = unLabeledHeaderStr.split(",");
        unLabeledDataList.add(unLabeledHeader);
        for (GdaiDatafile datafile : gdaiDatafileList) {
            //文件内容,标签数组
            String[] data = new String[2];
            RestResult<GdaiDatafile> result = queryFullText(datafile);
            if (result.getCode() == "200") {
                data[0] = result.getData().getShortText();
            }
            data[1] = "";
            JSONArray array = new JSONArray();
            List<GdaiDatafileLabelVo> datafileLabelVos = gdaiDatafileLabelMapper.queryLabels(datafile.getDatafileId());
            if (datafileLabelVos != null && datafileLabelVos.size() > 0) {
                for (GdaiDatafileLabelVo datafileLabelVo : datafileLabelVos) {
                    BaseModel model = ModelUtil.createModel(dataset.getAnnotationType(), dataset.getAnnotationTemplate(), datafileLabelVo.getLabelData());
                    if (model == null) {
                        return RestResult.genFailResult("数据集类型错误");
                    }
                    JSONObject datafileLabe = (JSONObject) model.generateLabel(type);
                    array.add(datafileLabe);
                }
                data[1] = array.toJSONString();
                labeledDataList.add(data);
            } else {
                data[1] = String.valueOf(datafile.getDatafileId());
                unLabeledDataList.add(data);
            }
        }
    } else {
        return RestResult.genFailResult("未配置数据集ID生成格式");
    }
    boolean labeledCsvFile = FileUtil.createCSVFile(labeledDataList, dataset.getDatasetCephPath() + filePath);
    boolean unLabeledCsvFile = FileUtil.createCSVFile(unLabeledDataList, dataset.getDatasetCephPath() + cn.hutool.core.io.FileUtil.file(filePath).getParentFile() + "/test.csv");
    if (!labeledCsvFile || !unLabeledCsvFile) {
        return RestResult.genFailResult("生成失败");
    }
    return RestResult.genSuccessResult("生成成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.model.BaseModel
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.ModelUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
java.io.File
java.util.ArrayList
java.util.List
java.util.Map
java.util.Objects
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为getValueByKey的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据key获取value
     *
     * @param map
     * @param orgName
     * @return
     */
public String getValueByKey(Map<String, String> map, String orgName) {
    String value = null;
    if (map != null && !map.isEmpty()) {
        Iterator<String> iter = map.keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            if (orgName.equals(key)) {
                value = map.get(key);
                break;
            }
        }
    }
    return value;
}
### 类导入的包
java.util.Iterator
java.util.Set
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为uploadPicMethod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//public RestResult uploadPicMethod(Long datasetId, String markStatus, String dataType, String datasetCephPath, GdaiDatafileMapper gdaiDatafileMapper, GdaiDatalabelMapper gdaiDatalabelMapper, GdaiDatafileLabelMapper gdaiDatafileLabelMapper, Long creatorId, String zipFilePath, String zipConfFilePath, String fileName) {
public RestResult uploadPicMethod(Long datasetId, String markStatus, String dataType, String datasetCephPath, Long creatorId, String zipFilePath, String zipConfFilePath, String fileName) {
    //统计非规定类型文件数
    int count = 0;
    //读取压缩文件临时解压地址
    String destDirPath = null;
    //压缩文件路径+文件名称
    String zipPath = null;
    //断点续传临时目录+文件名称
    zipConfFilePath = zipConfFilePath + "/" + fileName + ".conf";
    //创建临时Map用来存放重命名的文件名称
    Map<String, String> map;
    FileInputStream fist = null;
    try {
        //临时解压地址
        destDirPath = zipFilePath + "/temp";
        //读取压缩文件内容
        zipPath = zipFilePath + "/" + fileName;
        Set<String> set = ZipUtil.readZip(zipPath, destDirPath, zipFilePath);
        if (set == null || set.size() == 0) {
            return RestResult.genFailResult("读取压缩文件失败");
        }
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String filePath = iterator.next();
            //该集合用来存放已经上传的图片信息
            List<GdaiDatafile> fileList = new ArrayList<>();
            GdaiDatafile gdaiDatafile;
            //该集合用来存放解析的json文件坐标信息
            List<GdaiDatafileLabelVo> labelList = new ArrayList<>();
            //遍历解压之后目录下所有文件
            File[] fs = FileUtils.getFile(filePath).listFiles();
            if (fs != null && fs.length > 0) {
                map = new HashMap<>();
                int jsonCount = 0;
                int picCount = 0;
                for (File f : fs) {
                    if (f.isFile()) {
                        String exts = Files.getFileExtension(f.getAbsolutePath());
                        if ("json".equalsIgnoreCase(exts)) {
                            jsonCount++;
                        } else if ("jpg".equalsIgnoreCase(exts) || "png".equalsIgnoreCase(exts) || "jpeg".equalsIgnoreCase(exts)) {
                            picCount++;
                        }
                    }
                }
                if ("2".equals(markStatus)) {
                    if (jsonCount != picCount) {
                        throw new Exception("json文件与图片文件数量不对应，请检查");
                    }
                }
                for (File f : fs) {
                    if (f.isFile()) {
                        //获取解压之后文件后缀名
                        String fileExtension = Files.getFileExtension(f.getAbsolutePath());
                        if (!"jpg".equalsIgnoreCase(fileExtension) && !"png".equalsIgnoreCase(fileExtension) && !"jpeg".equalsIgnoreCase(fileExtension) && !"json".equalsIgnoreCase(fileExtension)) {
                            count++;
                        } else {
                            //图片上传之后将图片信息落库
                            MultipartFile multipartFile = FileUtil.getMultipartFile(f);
                            //获取文件大小
                            long size = multipartFile.getSize();
                            //获取原文件名称
                            String originalFilename = multipartFile.getOriginalFilename();
                            String[] name = originalFilename.split("\\.");
                            String orgName = name[0];
                            //对临时文件进行重命名
                            String absolutePath = f.getAbsolutePath().replace(originalFilename, "").trim();
                            String newFileName;
                            String oldPath;
                            String newPath;
                            String id = UuidUtils.uuid();
                            //根据文件名称从map中找到对应新名称
                            String value = getValueByKey(map, orgName);
                            String[] split = originalFilename.split("\\.");
                            if (StringUtils.isBlank(value)) {
                                newFileName = id + "." + fileExtension;
                                oldPath = absolutePath + File.separator + originalFilename;
                                newPath = absolutePath + File.separator + newFileName;
                                FileUtils.getFile(oldPath).renameTo(FileUtils.getFile(newPath));
                                //将文件新名称存放在map中
                                map.put(split[0], id);
                            } else {
                                newFileName = value + "." + split[1];
                                oldPath = absolutePath + File.separator + originalFilename;
                                newPath = absolutePath + File.separator + newFileName;
                                FileUtils.getFile(oldPath).renameTo(FileUtils.getFile(newPath));
                            }
                            //创建原图上传路径
                            String path2 = datasetCephPath + "/source/";
                            FileUtil.createDir(path2);
                            //获取重命名文件输入流,将原图片流转为MultipartFile类型
                            fist = new FileInputStream(newPath);
                            MultipartFile mf2 = FileUtil.getMultipartFile(fist, newFileName);
                            String path1;
                            String iconName;
                            int height;
                            int width;
                            if (!"json".equals(fileExtension)) {
                                //调用封装方法，将原始图片转成微缩图
                                byte[] fileBytes = picTransformStream(newPath);
                                //获取图片尺寸
                                BufferedImage originalImage = ImageIO.read(new ByteArrayInputStream(fileBytes));
                                height = originalImage.getHeight();
                                width = originalImage.getWidth();
                                BufferedImage bufferedImage = Thumbnails.of(originalImage).scale(Double.parseDouble(scale)).asBufferedImage();
                                //将转换后的微缩图也上传ceph
                                iconName = "thumb_" + newFileName;
                                //微缩图转为输入流,将微缩图流转为MultipartFile类型
                                MultipartFile mf = FileUtil.getMultipartFile(FileUtil.bufferedImageToInputStream(bufferedImage), iconName);
                                //创建微缩图上传路径
                                path1 = datasetCephPath + "/thumb/";
                                FileUtil.createDir(path1);
                                //将微缩图上传
                                mf.transferTo(FileUtils.getFile(path1 + iconName));
                                gdaiDatafile = new GdaiDatafile(newFileName, datasetId, path2 + newFileName, path1 + iconName, size, height, width, "1", markStatus, " ", originalFilename, creatorId, new Date(), new Date());
                                gdaiDatafileMapper.add(gdaiDatafile);
                                gdaiDatafile.setDatafileId(gdaiDatafile.getDatafileId());
                                //最终将上传之后的文件信息放入集合
                                fileList.add(gdaiDatafile);
                            }
                            //将原图片上传
                            mf2.transferTo(FileUtils.getFile(path2 + newFileName));
                            if ("2".equals(markStatus) && "json".equals(fileExtension)) {
                                //调用封装的方法，解析json文件
                                analysisJsonFile(path2 + newFileName, newFileName, labelList);
                            }
                        }
                    }
                }
            }
            //将上传文件名称和对应json文件名称对比解析落库(只有表明是2-已标注才落库标注信息)
            if ("2".equals(markStatus)) {
                //将上传文件名称和对应json文件名称对比解析落库
                saveJsonData(fileList, labelList, datasetId, dataType);
            }
        }
    } catch (Exception e) {
        log.info("流关闭异常" + e);
        return RestResult.genFailResult("流关闭异常");
    } finally {
        if (fist != null) {
            IOUtils.closeQuietly(fist);
        }
        if (StringUtils.isNotBlank(destDirPath)) {
            File filePath = FileUtils.getFile(destDirPath);
            if (filePath.exists()) {
                FileUtil.deleteFile(filePath);
            }
        }
        if (StringUtils.isNotBlank(zipPath)) {
            File zipFile = FileUtils.getFile(zipPath);
            if (zipFile.exists()) {
                FileUtil.deleteFile(zipFile);
            }
        }
        if (StringUtils.isNotBlank(zipConfFilePath)) {
            File zipConfFile = FileUtils.getFile(zipConfFilePath);
            if (zipConfFile.exists()) {
                FileUtil.deleteFile(zipConfFile);
            }
        }
    }
    if (count > 0) {
        return RestResult.genSuccessResult("上传完毕,其中存在" + count + "个非规定类型文件未进行上传");
    }
    return RestResult.genSuccessResult("上传完毕");
}
### 类导入的包
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.Result
com.google.common.io.Files
net.coobird.thumbnailator.Thumbnails
org.apache.commons.compress.utils.IOUtils
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.beans.factory.annotation.Value
org.springframework.web.multipart.MultipartFile
javax.imageio.ImageIO
java.awt.image.BufferedImage
java.io.ByteArrayInputStream
java.io.File
java.io.FileInputStream
java.io.InputStream
java.util.ArrayList
java.util.Date
java.util.HashMap
java.util.Iterator
java.util.List
java.util.Map
java.util.Set
### 类级别的变量
/**
 * 图片压缩比例
 */
@Value("${file.scale}")
private String scale;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为uploadTxtMethod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param datasetId
     * @param markStatus
     * @param dataType
     * @param datasetCephPath
     * @param creatorId
     * @param zipFilePath
     * @param zipConfFilePath
     * @param fileName
     * @return
     */
public RestResult uploadTxtMethod(Long datasetId, String markStatus, String dataType, String datasetCephPath, Long creatorId, String zipFilePath, String zipConfFilePath, String fileName) {
    //统计非规定类型文件数
    int count = 0;
    //读取压缩文件临时解压地址
    String destDirPath = null;
    //压缩文件路径+文件名称
    String zipPath = null;
    //断点续传临时目录+文件名称
    zipConfFilePath = zipConfFilePath + "/" + fileName + ".conf";
    //创建临时Map用来存放重命名的文件名称
    Map<String, String> map;
    FileInputStream fis = null;
    try {
        //临时解压地址
        destDirPath = zipFilePath + "/temp";
        //读取压缩文件内容
        zipPath = zipFilePath + "/" + fileName;
        Set<String> set = ZipUtil.readZip(zipPath, destDirPath, zipFilePath);
        if (set == null || set.size() == 0) {
            return RestResult.genFailResult("读取压缩文件失败");
        }
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String filePath = iterator.next();
            //该集合用来存放已经上传的文本信息
            List<GdaiDatafile> fileList = new ArrayList<>();
            GdaiDatafile gdaiDatafile;
            //该集合用来存放解析的json文件坐标信息
            List<GdaiDatafileLabelVo> labelList = new ArrayList<>();
            //遍历解压之后目录下所有文件
            File[] fs = FileUtils.getFile(filePath).listFiles();
            if (fs != null && fs.length > 0) {
                map = new HashMap<>();
                int jsonCount = 0;
                int txtCount = 0;
                for (File f : fs) {
                    if (f.isFile()) {
                        String exts = Files.getFileExtension(f.getAbsolutePath());
                        if ("json".equalsIgnoreCase(exts)) {
                            jsonCount++;
                        } else if ("txt".equalsIgnoreCase(exts)) {
                            txtCount++;
                        }
                    }
                }
                if ("2".equals(markStatus)) {
                    if (jsonCount != txtCount) {
                        throw new Exception("json文件与文本文件数量不对应，请检查");
                    }
                }
                for (File f : fs) {
                    if (f.isFile()) {
                        //获取解压之后文件后缀名
                        String fileExtension = Files.getFileExtension(f.getAbsolutePath());
                        if (!"txt".equalsIgnoreCase(fileExtension) && !"json".equalsIgnoreCase(fileExtension)) {
                            count++;
                        } else {
                            //文件上传之后将文件信息落库
                            MultipartFile multipartFile = FileUtil.getMultipartFile(f);
                            //获取文件大小
                            long size = multipartFile.getSize();
                            //获取原文件名称
                            String originalFilename = multipartFile.getOriginalFilename();
                            String[] name = originalFilename.split("\\.");
                            String orgName = name[0];
                            //对临时文件进行重命名
                            String absolutePath = f.getAbsolutePath().replace(originalFilename, "").trim();
                            String newFileName;
                            String oldPath;
                            String newPath;
                            String id = UuidUtils.uuid();
                            //根据文件名称从map中找到对应新名称
                            String value = getValueByKey(map, orgName);
                            String[] split = originalFilename.split("\\.");
                            if (StringUtils.isBlank(value)) {
                                newFileName = id + "." + fileExtension;
                                oldPath = absolutePath + File.separator + originalFilename;
                                newPath = absolutePath + File.separator + newFileName;
                                FileUtils.getFile(oldPath).renameTo(FileUtils.getFile(newPath));
                                //将文件新名称存放在map中
                                map.put(split[0], id);
                            } else {
                                newFileName = value + "." + split[1];
                                oldPath = absolutePath + File.separator + originalFilename;
                                newPath = absolutePath + File.separator + newFileName;
                                FileUtils.getFile(oldPath).renameTo(FileUtils.getFile(newPath));
                            }
                            //读取临时文件下txt文件中指定长度字符
                            String shortText = FileUtil.readTxt(newPath);
                            //获取重命名文件输入流,将文件流转为MultipartFile类型
                            fis = new FileInputStream(newPath);
                            MultipartFile mf = FileUtil.getMultipartFile(fis, newFileName);
                            //创建文件上传路径
                            String path = datasetCephPath + "/source/";
                            FileUtil.createDir(path);
                            //将文件上传
                            mf.transferTo(FileUtils.getFile(path + newFileName));
                            if (!"json".equals(fileExtension)) {
                                gdaiDatafile = new GdaiDatafile(newFileName, datasetId, path + newFileName, " ", shortText, size, "1", markStatus, " ", originalFilename, creatorId, new Date(), new Date());
                                gdaiDatafileMapper.add(gdaiDatafile);
                                gdaiDatafile.setDatafileId(gdaiDatafile.getDatafileId());
                                //最终将上传之后的文件信息放入集合
                                fileList.add(gdaiDatafile);
                            }
                            if ("2".equals(markStatus) && "json".equals(fileExtension)) {
                                //调用封装的方法，解析json文件
                                analysisJsonFile(path + newFileName, newFileName, labelList);
                            }
                        }
                    }
                }
            }
            //将上传文件名称和对应json文件名称对比解析落库(只有表明是2-已标注才落库标注信息)
            if ("2".equals(markStatus)) {
                //将上传文件名称和对应json文件名称对比解析落库
                saveJsonData(fileList, labelList, datasetId, dataType);
            }
        }
    } catch (Exception e) {
        log.info("流关闭异常" + e);
        return RestResult.genFailResult("流关闭异常");
    } finally {
        if (fis != null) {
            IOUtils.closeQuietly(fis);
        }
        //要删除的临时文件地址
        if (StringUtils.isNotBlank(destDirPath)) {
            File filePath = FileUtils.getFile(destDirPath);
            if (filePath.exists()) {
                FileUtil.deleteFile(filePath);
            }
        }
        if (StringUtils.isNotBlank(zipPath)) {
            File zipFile = FileUtils.getFile(zipPath);
            if (zipFile.exists()) {
                FileUtil.deleteFile(zipFile);
            }
        }
        if (StringUtils.isNotBlank(zipConfFilePath)) {
            File zipConfFile = FileUtils.getFile(zipConfFilePath);
            if (zipConfFile.exists()) {
                FileUtil.deleteFile(zipConfFile);
            }
        }
    }
    if (count > 0) {
        return RestResult.genSuccessResult("上传完毕,其中存在" + count + "个非规定类型文件未进行上传");
    }
    return RestResult.genSuccessResult("上传完毕");
}
### 类导入的包
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.Result
com.google.common.io.Files
org.apache.commons.compress.utils.IOUtils
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.beans.factory.annotation.Value
org.springframework.web.multipart.MultipartFile
java.io.File
java.io.FileInputStream
java.io.InputStream
java.util.ArrayList
java.util.Date
java.util.HashMap
java.util.Iterator
java.util.List
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为uploadVideoMethod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param datasetId
     * @param markStatus
     * @param dataType
     * @param datasetCephPath
     * @param creatorId
     * @param zipFilePath
     * @param zipConfFilePath
     * @param fileName
     * @return
     */
public RestResult uploadVideoMethod(Long datasetId, String markStatus, String dataType, String datasetCephPath, Long creatorId, String zipFilePath, String zipConfFilePath, String fileName) {
    //统计非规定类型文件数
    int count = 0;
    //读取压缩文件临时解压地址
    String destDirPath = null;
    //压缩文件路径+文件名称
    String zipPath = null;
    //断点续传临时目录+文件名称
    zipConfFilePath = zipConfFilePath + "/" + fileName + ".conf";
    //创建临时Map用来存放重命名的文件名称
    Map<String, String> map;
    FileInputStream fist = null;
    try {
        //临时解压地址
        destDirPath = zipFilePath + "/temp";
        //读取压缩文件内容
        zipPath = zipFilePath + "/" + fileName;
        Set<String> set = ZipUtil.readZip(zipPath, destDirPath, zipFilePath);
        if (set == null || set.size() == 0) {
            return RestResult.genFailResult("读取压缩文件失败");
        }
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String filePath = iterator.next();
            //该集合用来存放已经上传的视频信息
            List<GdaiDatafile> fileList = new ArrayList<>();
            GdaiDatafile gdaiDatafile;
            //该集合用来存放解析的json文件坐标信息
            List<GdaiDatafileLabelVo> labelList = new ArrayList<>();
            //遍历解压之后目录下所有文件
            File[] fs = FileUtils.getFile(filePath).listFiles();
            if (fs != null && fs.length > 0) {
                map = new HashMap<>();
                int jsonCount = 0;
                int videoCount = 0;
                for (File f : fs) {
                    if (f.isFile()) {
                        String exts = Files.getFileExtension(f.getAbsolutePath());
                        if ("json".equalsIgnoreCase(exts)) {
                            jsonCount++;
                        } else if ("mp4".equalsIgnoreCase(exts)) {
                            videoCount++;
                        }
                    }
                }
                if ("2".equals(markStatus)) {
                    if (jsonCount != videoCount) {
                        throw new Exception("json文件与视频文件数量不对应，请检查");
                    }
                }
                for (File f : fs) {
                    if (f.isFile()) {
                        //获取解压之后文件后缀名
                        String fileExtension = Files.getFileExtension(f.getAbsolutePath());
                        if (!"mp4".equalsIgnoreCase(fileExtension) && !"json".equalsIgnoreCase(fileExtension)) {
                            count++;
                        } else {
                            //视频上传之后将视频信息落库
                            MultipartFile multipartFile = FileUtil.getMultipartFile(f);
                            //获取文件大小
                            long size = multipartFile.getSize();
                            //获取原文件名称
                            String originalFilename = multipartFile.getOriginalFilename();
                            String[] name = originalFilename.split("\\.");
                            String orgName = name[0];
                            //获取文件名称
                            String absolutePath = f.getAbsolutePath().replace(originalFilename, "").trim();
                            String id = UuidUtils.uuid();
                            String newFileName = id + "." + fileExtension;
                            String newPath = absolutePath + File.separator + newFileName;
                            //对文件进行转码生产新文件
                            VideoEncodeUtil.VideoEncode(f.getAbsolutePath(), newPath);
                            //转码完成删除源文件
                            FileUtil.deleteFile(f.getAbsolutePath());
                            //根据文件名称从map中找到对应新名称
                            String value = getValueByKey(map, orgName);
                            String[] split = newFileName.split("\\.");
                            if (StringUtils.isBlank(value)) {
                                //将文件新名称存放在map中
                                map.put(split[0], id);
                            }
                            //创建原视频上传路径
                            String path2 = datasetCephPath + "/source/";
                            FileUtil.createDir(path2);
                            //获取转码文件输入流,将原视频流转为MultipartFile类型
                            fist = new FileInputStream(newPath);
                            MultipartFile mf2 = FileUtil.getMultipartFile(fist, newFileName);
                            //将原视频上传
                            mf2.transferTo(FileUtils.getFile(path2 + newFileName));
                            String path1;
                            String iconName;
                            int height;
                            int width;
                            if (!"json".equals(fileExtension)) {
                                //创建微缩图存储路径（包含微缩图名称）
                                String iconFileName = id + ".jpg";
                                iconName = "thumb_" + iconFileName;
                                path1 = datasetCephPath + "/thumb/";
                                if (!(FileUtils.getFile(path1)).exists()) {
                                    FileUtil.createDir(path1);
                                }
                                //调用封装方法，获取原始视频信息并生产微缩图
                                Map<String, String> videoMap = generateThumbnail(newPath, path1 + iconName, 1);
                                if (videoMap == null) {
                                    return RestResult.genFailResult("获取上传视频文件信息失败");
                                }
                                //获取视频宽和高
                                width = Integer.parseInt(videoMap.get("originalWidth"));
                                height = Integer.parseInt(videoMap.get("originalHeight"));
                                //拼装获取的视频文件信息为JSON字符串，最终放入到fileData字段
                                String fileData = JSON.toJSONString(videoMap);
                                //数据入库
                                gdaiDatafile = new GdaiDatafile(newFileName, datasetId, path2 + newFileName, path1 + iconName, size, height, width, "1", markStatus, fileData, originalFilename, creatorId, new Date(), new Date());
                                gdaiDatafileMapper.add(gdaiDatafile);
                                gdaiDatafile.setDatafileId(gdaiDatafile.getDatafileId());
                                //最终将上传之后的文件信息放入集合
                                fileList.add(gdaiDatafile);
                            }
                            if ("2".equals(markStatus) && "json".equals(fileExtension)) {
                                //调用封装的方法，解析json文件
                                analysisJsonFile(path2 + newFileName, newFileName, labelList);
                            }
                        }
                    }
                }
            }
            //将上传文件名称和对应json文件名称对比解析落库(只有表明是2-已标注才落库标注信息)
            if ("2".equals(markStatus)) {
                //将上传文件名称和对应json文件名称对比解析落库
                saveJsonData(fileList, labelList, datasetId, dataType);
            }
        }
    } catch (Exception e) {
        log.info("流关闭异常" + e);
        return RestResult.genFailResult("流关闭异常");
    } finally {
        if (fist != null) {
            IOUtils.closeQuietly(fist);
        }
        if (StringUtils.isNotBlank(destDirPath)) {
            File filePath = FileUtils.getFile(destDirPath);
            if (filePath.exists()) {
                FileUtil.deleteFile(filePath);
            }
        }
        if (StringUtils.isNotBlank(zipPath)) {
            File zipFile = FileUtils.getFile(zipPath);
            if (zipFile.exists()) {
                FileUtil.deleteFile(zipFile);
            }
        }
        if (StringUtils.isNotBlank(zipConfFilePath)) {
            File zipConfFile = FileUtils.getFile(zipConfFilePath);
            if (zipConfFile.exists()) {
                FileUtil.deleteFile(zipConfFile);
            }
        }
    }
    if (count > 0) {
        return RestResult.genSuccessResult("上传完毕,其中存在" + count + "个非规定类型文件未进行上传");
    }
    return RestResult.genSuccessResult("上传完毕");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.util.VideoEncodeUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.Result
com.google.common.io.Files
org.apache.commons.compress.utils.IOUtils
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.beans.factory.annotation.Value
org.springframework.web.multipart.MultipartFile
java.io.File
java.io.FileInputStream
java.io.InputStream
java.util.ArrayList
java.util.Date
java.util.HashMap
java.util.Iterator
java.util.List
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为saveJsonData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * json坐标信息落库
     *
     * @param fileList
     * @param labelList
     * @param datasetId
     * @param dataType
     */
public void saveJsonData(List<GdaiDatafile> fileList, List<GdaiDatafileLabelVo> labelList, Long datasetId, String dataType) {
    GdaiDatafileLabel gdaiDatafileLabel = null;
    GdaiDatalabel gdaiDatalabel;
    Long datalabelId;
    //将上传文件名称和对应json文件名称对比解析落库
    for (int i = 0; i < fileList.size(); i++) {
        GdaiDatafile datafile = fileList.get(i);
        String uploadFileName = datafile.getFileName();
        String[] split = uploadFileName.split("\\.");
        uploadFileName = split[0];
        for (int j = 0; j < labelList.size(); j++) {
            GdaiDatafileLabelVo labelVo = labelList.get(j);
            String jsonFileName = labelVo.getJsonName();
            String[] split1 = jsonFileName.split("\\.");
            jsonFileName = split1[0];
            if (uploadFileName.equals(jsonFileName)) {
                //两者文件名称相同，表示为同一组，获取文件存储的ID
                Long datafileId = datafile.getDatafileId();
                String jsonArray = labelVo.getJsonArray();
                JSONArray objects = JSONObject.parseArray(jsonArray);
                Iterator<Object> iterator = objects.stream().iterator();
                while (iterator.hasNext()) {
                    Object next = iterator.next();
                    JSONObject json = (JSONObject) JSONObject.toJSON(next);
                    //获取标签名称，根据标签名称查询标签管理表是否存在，存在则返回ID，不存在则新增标签
                    String labelName = null;
                    if ("pic".equalsIgnoreCase(dataType)) {
                        labelName = json.get("label_name").toString();
                    } else if ("txt".equalsIgnoreCase(dataType)) {
                        labelName = json.get("name").toString();
                    }
                    gdaiDatalabel = new GdaiDatalabel(datasetId, labelName);
                    //根据解析出的标签名称在数据库查询是否存在
                    GdaiDatalabel gdaiDatalabelInfo = gdaiDatalabelMapper.selectOne(gdaiDatalabel);
                    if (gdaiDatalabelInfo == null) {
                        //若为空则插入该标签
                        if ("pic".equalsIgnoreCase(dataType)) {
                            gdaiDatalabel = new GdaiDatalabel(datasetId, labelName, LABEL_COLOR, new Date(), new Date());
                        } else if ("txt".equalsIgnoreCase(dataType)) {
                            gdaiDatalabel = new GdaiDatalabel(datasetId, labelName, new Date(), new Date());
                        }
                        gdaiDatalabelMapper.insert(gdaiDatalabel);
                        datalabelId = gdaiDatalabel.getDatalabelId();
                    } else {
                        //若存在则返回标签ID
                        datalabelId = gdaiDatalabelInfo.getDatalabelId();
                    }
                    if ("pic".equalsIgnoreCase(dataType)) {
                        json.remove("label_name");
                        gdaiDatafileLabel = new GdaiDatafileLabel(datasetId, datafileId, datalabelId, json, null, null);
                    } else if ("txt".equalsIgnoreCase(dataType)) {
                        gdaiDatafileLabel = new GdaiDatafileLabel(datasetId, datafileId, datalabelId);
                    }
                    GdaiDatafileLabel datafileLabel = null;
                    if (gdaiDatafileLabel != null) {
                        datafileLabel = gdaiDatafileLabelMapper.selectOne(gdaiDatafileLabel);
                    }
                    if (datafileLabel == null) {
                        if ("pic".equalsIgnoreCase(dataType)) {
                            gdaiDatafileLabel = new GdaiDatafileLabel(datasetId, datafileId, datalabelId, json, new Date(), new Date());
                        } else if ("txt".equalsIgnoreCase(dataType)) {
                            gdaiDatafileLabel = new GdaiDatafileLabel(datasetId, datafileId, datalabelId);
                        }
                        gdaiDatafileLabelMapper.insert(gdaiDatafileLabel);
                    }
                }
            }
        }
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
java.io.File
java.util.Date
java.util.Iterator
java.util.List
java.util.Map
### 类级别的变量
/**
 * 默认框颜色
 */
private static final String LABEL_COLOR = "59,117,255";
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为picTransformStream的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将原图片转换为图片流
     *
     * @param newPath
     * @return
     */
public byte[] picTransformStream(String newPath) {
    FileInputStream fis = null;
    byte[] fileBytes = null;
    try {
        File files = FileUtils.getFile(newPath);
        fis = new FileInputStream(FileUtils.getFile(newPath));
        fileBytes = new byte[(int) files.length()];
        fis.read(fileBytes);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (fis != null) {
                fis.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return fileBytes;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.io.FileUtils
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为analysisJsonFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 解析json文件
     *
     * @param path
     * @param newFileName
     * @param labelList
     */
public void analysisJsonFile(String path, String newFileName, List<GdaiDatafileLabelVo> labelList) {
    FileInputStream fis = null;
    BufferedReader br = null;
    try {
        fis = new FileInputStream(FileUtils.getFile(path));
        br = new BufferedReader(new InputStreamReader(fis, "UTF-8"));
        String lineTxt;
        // 逐行读取
        while ((lineTxt = br.readLine()) != null) {
            GdaiDatafileLabelVo gdaiDatafileLabelVo = new GdaiDatafileLabelVo();
            //将读取到的每行进行解析
            JSONObject jsonObject = JSONObject.parseObject(lineTxt);
            String labels = jsonObject.getString("labels");
            gdaiDatafileLabelVo.setJsonName(newFileName);
            gdaiDatafileLabelVo.setJsonArray(labels);
            labelList.add(gdaiDatafileLabelVo);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (br != null) {
                br.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (fis != null) {
                fis.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
org.apache.commons.io.FileUtils
java.io.BufferedReader
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
java.io.InputStreamReader
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为readFromCeph的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 从ceph上下载该txt文件读取文本信息
     *
     * @param cephUrl
     * @return
     */
public StringBuilder readFromCeph(String cephUrl) {
    StringBuilder sb = new StringBuilder();
    InputStream inputStream = null;
    BufferedReader br = null;
    try {
        inputStream = FileUtil.readStreamObject(cephUrl);
        br = new BufferedReader(new InputStreamReader(inputStream));
        String len;
        while ((len = br.readLine()) != null) {
            sb.append(len);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (br != null) {
                br.close();
            }
            if (inputStream != null) {
                inputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return sb;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.FileUtil
java.io.BufferedReader
java.io.File
java.io.IOException
java.io.InputStream
java.io.InputStreamReader
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为checkGdaiDatafile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiDatafile checkGdaiDatafile(User user, Long datafileId) throws TrainginCenterException {
    GdaiDatafile datafile = gdaiDatafileMapper.selectById(datafileId);
    if (datafile == null) {
        throw new TrainginCenterException("未查询到该文件信息");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(datafile.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return datafile;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为checkRoleGdaiDatafile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiDatafile checkRoleGdaiDatafile(User user, Long datafileId) throws TrainginCenterException {
    GdaiDatafile datafile = gdaiDatafileMapper.selectById(datafileId);
    if (datafile == null) {
        throw new TrainginCenterException("未查询到该文件信息");
    } else {
        //判断登录用户角色
        boolean aiLabelOperRole = SessionUtils.isAiLabeloperRole(user);
        //AI模型开发员角色 aimodeldev
        boolean aiModelDevRole = SessionUtils.isAiModelDevRole(user);
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole || aiLabelOperRole || aiModelDevRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(datafile.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return datafile;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为generateThumbnail的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 生成视频缩略图，获取视频基本信息
     *
     * @param videoFilePath
     * @param thumbnailFilePath
     * @param scaleFactor
     * @throws Exception
     */
public static Map<String, String> generateThumbnail(String videoFilePath, String thumbnailFilePath, double scaleFactor) throws Exception {
    Map<String, String> map = null;
    FFmpegFrameGrabber grabber = FFmpegFrameGrabber.createDefault(videoFilePath);
    Frame frame = null;
    try {
        grabber.start();
        // 获取视频时长（秒）
        long duration = grabber.getLengthInTime() / (1000 * 1000);
        // 获取视频帧速率
        double fps = grabber.getVideoFrameRate();
        // 对帧速率进行取整
        int roundedFps = (int) (fps);
        // 计算总帧数
        int totalFrames = getVideoFrameTotalLength(new File(videoFilePath));
        // 获取视频的宽度和高度
        int originalWidth = grabber.getImageWidth();
        int originalHeight = grabber.getImageHeight();
        // 计算缩略图的宽度和高度
        int thumbnailWidth = (int) (originalWidth * scaleFactor);
        int thumbnailHeight = (int) (originalHeight * scaleFactor);
        //设置视频截取帧（默认取第一帧）
        //            frame = grabber.grabImage();
        int length = grabber.getLengthInFrames();
        int i = 0;
        while (i < length) {
            // 过滤前5帧，避免出现全黑的图片，依自己情况而定
            frame = grabber.grabImage();
            if ((i > 5) && (frame.image != null)) {
                break;
            }
            i++;
        }
        if (frame != null) {
            Java2DFrameConverter converter = new Java2DFrameConverter();
            BufferedImage bufferedImage = converter.getBufferedImage(frame);
            if (bufferedImage != null) {
                // 创建一个新的BufferedImage用于存储缩略图
                BufferedImage scaledImage = new BufferedImage(thumbnailWidth, thumbnailHeight, BufferedImage.TYPE_INT_RGB);
                // 绘制并缩放图像
                java.awt.Graphics2D g2d = scaledImage.createGraphics();
                g2d.drawImage(bufferedImage.getScaledInstance(thumbnailWidth, thumbnailHeight, java.awt.Image.SCALE_SMOOTH), 0, 0, null);
                g2d.dispose();
                // 保存缩略图
                ImageIO.write(scaledImage, "jpg", new File(thumbnailFilePath));
                map = new HashMap<>();
                map.put("duration", String.valueOf(duration));
                map.put("roundedFps", String.valueOf(roundedFps));
                map.put("totalFrames", String.valueOf(totalFrames));
                map.put("originalWidth", String.valueOf(originalWidth));
                map.put("originalHeight", String.valueOf(originalHeight));
                return map;
            } else {
                log.info("Failed to convert frame to BufferedImage.");
            }
        }
    } finally {
        // 确保无论是否发生异常都停止grabber
        grabber.stop();
    }
    return map;
}
### 类导入的包
org.bytedeco.javacv.FFmpegFrameGrabber
org.bytedeco.javacv.Frame
org.bytedeco.javacv.FrameGrabber
org.bytedeco.javacv.Java2DFrameConverter
javax.imageio.ImageIO
java.awt.image.BufferedImage
java.io.File
java.util.HashMap
java.util.Map
### 类级别的变量
/**
 * 图片压缩比例
 */
@Value("${file.scale}")
private String scale;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatafileServiceImpl中有一个名为getVideoFrameTotalLength的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取视频总帧数
     *
     * @return
     */
public static int getVideoFrameTotalLength(File file) {
    int frameCount = 0;
    try {
        FFmpegFrameGrabber ff = new FFmpegFrameGrabber(file);
        ff.start();
        org.bytedeco.javacv.Frame frame;
        while ((frame = ff.grabImage()) != null) {
            frameCount++;
        }
        ff.stop();
    } catch (FrameGrabber.Exception e) {
        throw new RuntimeException(e);
    }
    return frameCount;
}
### 类导入的包
org.bytedeco.javacv.FFmpegFrameGrabber
org.bytedeco.javacv.Frame
org.bytedeco.javacv.FrameGrabber
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatalabelServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiDatalabel gdaiDatalabel) throws TrainginCenterException {
    log.info("GdaiDatalabelServiceImpl.add params:" + JSON.toJSONString(gdaiDatalabel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    gdaiDatasetService.checkGdaiDataset(user, gdaiDatalabel.getDatasetId());
    try {
        GdaiDatalabel gdaiDatalabelInfo = gdaiDatalabelMapper.selectOne(gdaiDatalabel);
        if (gdaiDatalabelInfo != null) {
            return RestResult.genFailResult("该标签名已存在");
        }
        Date curDate = new Date();
        gdaiDatalabel.setCreateTime(curDate);
        gdaiDatalabel.setModifyTime(curDate);
        gdaiDatalabel.setCreatorId(userId);
        gdaiDatalabelMapper.insert(gdaiDatalabel);
    } catch (Exception e) {
        log.info("新增标签异常", e);
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult(gdaiDatalabel.getDatalabelId());
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatalabelService
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatasetService gdaiDatasetService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatalabelServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiDatalabel gdaiDatalabel) throws TrainginCenterException {
    log.info("GdaiDatalabelServiceImpl.update params:" + JSON.toJSONString(gdaiDatalabel));
    Long datalabelId = gdaiDatalabel.getDatalabelId();
    if (datalabelId == null) {
        return RestResult.genFailResult("标签ID不能为空");
    }
    String labelName = gdaiDatalabel.getLabelName();
    if (StringUtils.isBlank(labelName)) {
        return RestResult.genFailResult("标签名称不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatalabel datalabel = checkGdaiDatalabel(user, datalabelId);
    try {
        GdaiDatalabel gdaiDatalabelInfo = gdaiDatalabelMapper.selectOne(new GdaiDatalabel(gdaiDatalabel.getDatasetId(), gdaiDatalabel.getLabelName()));
        if (gdaiDatalabelInfo != null) {
            return RestResult.genFailResult("该标签名已存在");
        }
        BeanUtils.copyProperties(gdaiDatalabel, datalabel);
        Date curDate = new Date();
        datalabel.setModifyTime(curDate);
        datalabel.setModifierId(user.getId());
        gdaiDatalabelMapper.updateById(datalabel);
    } catch (Exception e) {
        log.info("修改标签异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.service.GdaiDatalabelService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatalabelServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiDatalabel gdaiDatalabel) throws TrainginCenterException {
    log.info("GdaiDatalabelServiceImpl.delete params:" + JSON.toJSONString(gdaiDatalabel));
    Long datalabelId = gdaiDatalabel.getDatalabelId();
    if (datalabelId == null) {
        return RestResult.genFailResult("标签ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatalabel datalabel = checkGdaiDatalabel(user, datalabelId);
    try {
        //删除标签之前检查该标签是否有被使用，如果有使用则不允许删除
        int count = gdaiDatafileLabelMapper.selectCount(new EntityWrapper<GdaiDatafileLabel>().eq(gdaiDatalabel.getDatalabelId() != null, "datalabel_id", gdaiDatalabel.getDatalabelId()));
        if (count > 0) {
            return RestResult.genFailResult("该标签已关联其他文件信息，不能删除。");
        } else {
            //根据标签ID删除标签
            gdaiDatalabelMapper.deleteById(gdaiDatalabel.getDatalabelId());
        }
    } catch (Exception e) {
        log.info("删除标签异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.service.GdaiDatalabelService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatalabelServiceImpl中有一个名为queryLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryLabel(GdaiDatalabelVo gdaiDatalabelVo) {
    log.info("GdaiDatalabelServiceImpl.queryLabel params:" + JSON.toJSONString(gdaiDatalabelVo));
    if (gdaiDatalabelVo == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    Long datasetId = gdaiDatalabelVo.getDatasetId();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    String flag = gdaiDatalabelVo.getFlag();
    if (StringUtils.isBlank(flag)) {
        return RestResult.genFailResult("查询标志不能为空");
    }
    List<GdaiDatalabelVo> gdaiDatalabelVos;
    try {
        //查询所有标签
        gdaiDatalabelVos = gdaiDatalabelMapper.queryLabel(gdaiDatalabelVo);
        //根据数据集ID查询该数据集下所有标签对应的标注框数
        List<GdaiDatafileLabelVo> gdaiDatafileLabelVos;
        if ("0".equals(flag)) {
            gdaiDatafileLabelVos = gdaiDatafileLabelMapper.queryFlagCountById(datasetId);
        } else if ("1".equals(flag)) {
            gdaiDatafileLabelVos = gdaiDatafileLabelMapper.queryTempFlagCountById(datasetId);
        } else {
            return RestResult.genFailResult("查询标志错误");
        }
        if (gdaiDatalabelVos != null && gdaiDatalabelVos.size() > 0) {
            if (gdaiDatafileLabelVos == null) {
                for (GdaiDatalabelVo vo : gdaiDatalabelVos) {
                    vo.setFrameCount(0);
                }
            } else {
                for (int i = 0; i < gdaiDatalabelVos.size(); i++) {
                    long datalabelId = gdaiDatalabelVos.get(i).getDatalabelId();
                    for (int j = 0; j < gdaiDatafileLabelVos.size(); j++) {
                        long datalabelId1 = gdaiDatafileLabelVos.get(j).getDatalabelId();
                        int frameCount = gdaiDatafileLabelVos.get(j).getFrameCount();
                        if (datalabelId == datalabelId1) {
                            gdaiDatalabelVos.get(i).setFrameCount(frameCount);
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("查询标签异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiDatalabelVos);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.service.GdaiDatalabelService
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.GdaiDatalabelVo
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatalabelServiceImpl中有一个名为checkGdaiDatalabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiDatalabel checkGdaiDatalabel(User user, Long datalabelId) throws TrainginCenterException {
    GdaiDatalabel datalabel = gdaiDatalabelMapper.selectById(datalabelId);
    if (datalabel == null) {
        throw new TrainginCenterException("未查询到该标签信息");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(datalabel.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return datalabel;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiDatasetGroupVo gdaiDatasetGroupVo) {
    log.info("GdaiDatasetGroupServiceImpl.add params: " + JSON.toJSONString(gdaiDatasetGroupVo));
    try {
        //新增之前根据数据集名称查询看是否已存在该名称的数据集
        GdaiDatasetGroup gdaiDatasetGroup = gdaiDatasetGroupService.selectOne(new EntityWrapper<GdaiDatasetGroup>().eq("dataset_name", gdaiDatasetGroupVo.getDatasetName()).eq("creator_id", gdaiDatasetGroupVo.getCreatorId()));
        if (gdaiDatasetGroup != null) {
            return RestResult.genFailResult("该数据集名称已存在");
        }
        Date curDate = new Date();
        //新增数据到数据集组表中
        GdaiDatasetGroup datasetGroup = new GdaiDatasetGroup();
        BeanUtils.copyProperties(gdaiDatasetGroupVo, datasetGroup);
        datasetGroup.setCreateTime(curDate);
        datasetGroup.setModifyTime(curDate);
        gdaiDatasetGroupMapper.insert(datasetGroup);
        //获取数据集组ID
        Long datasetGroupId = datasetGroup.getDatasetGroupId();
        //新增数据到数据集表中
        GdaiDataset gdaiDataset = new GdaiDataset();
        BeanUtils.copyProperties(gdaiDatasetGroupVo, gdaiDataset);
        gdaiDataset.setCreateTime(curDate);
        gdaiDataset.setModifyTime(curDate);
        gdaiDataset.setDatasetGroupId(datasetGroupId);
        //版本号默认从V1开始，之后依次递增
        gdaiDataset.setDatasetVersion(1L);
        gdaiDatasetMapper.insert(gdaiDataset);
        //获取数据集ID用来组装数据集文件存放在ceph的目录
        Long datasetId = gdaiDataset.getDatasetId();
        //拼装存储路径
        String dataType = gdaiDatasetGroupVo.getDataType();
        String datasetCephPath;
        String datasetFilePath;
        String datasetLabelPath;
        if ("pic".equalsIgnoreCase(dataType)) {
            datasetCephPath = cephUploadPath + picDataset + "/" + datasetId;
            datasetFilePath = cephUploadPath + picDataset + "/" + datasetId + "/datasets/files/";
            datasetLabelPath = cephUploadPath + picDataset + "/" + datasetId + "/datasets/labels/";
        } else if ("txt".equalsIgnoreCase(dataType)) {
            datasetCephPath = cephUploadPath + txtDataset + "/" + datasetId;
            datasetFilePath = cephUploadPath + txtDataset + "/" + datasetId + "/datasets/files/";
            datasetLabelPath = cephUploadPath + txtDataset + "/" + datasetId + "/datasets/labels/";
        } else if ("video".equalsIgnoreCase(dataType)) {
            datasetCephPath = cephUploadPath + videoDataset + "/" + datasetId;
            datasetFilePath = cephUploadPath + videoDataset + "/" + datasetId + "/datasets/files/";
            datasetLabelPath = cephUploadPath + videoDataset + "/" + datasetId + "/datasets/labels/";
        } else {
            return RestResult.genFailResult("数据集类型错误");
        }
        //创建对应目录
        FileUtil.createDir(datasetFilePath);
        FileUtil.createDir(datasetLabelPath);
        //根据ID设置该字段
        gdaiDataset.setDatasetCephPath(datasetCephPath);
        gdaiDataset.setDatasetFilePath(datasetFilePath);
        gdaiDataset.setDatasetLabelPath(datasetLabelPath);
        gdaiDatasetMapper.updateById(gdaiDataset);
    } catch (Exception e) {
        log.info("新增数据集异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
com.eshore.gdai.trainingcenter.util.FileUtil
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Date
### 类级别的变量
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * 数据集存放图片目录
 */
@Value("${cephUpload.picDataset}")
private String picDataset;
/**
 * 数据集存放文本目录
 */
@Value("${cephUpload.txtDataset}")
private String txtDataset;
/**
 * 数据集存放视频目录
 */
@Value("${cephUpload.videoDataset}")
private String videoDataset;
@Resource
private GdaiDatasetGroupService gdaiDatasetGroupService;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为queryDatasetGroup的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryDatasetGroup(GdaiDatasetGroupVo gdaiDatasetGroupVo) {
    log.info("GdaiDatasetGroupServiceImpl.queryDatasetGroup params: " + JSON.toJSONString(gdaiDatasetGroupVo));
    String dataType = gdaiDatasetGroupVo.getDataType();
    String datasetName = gdaiDatasetGroupVo.getDatasetName();
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    Long projectId = gdaiDatasetGroupVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    List<GdaiDatasetGroupVo> list = new ArrayList<>();
    GdaiDatasetGroupVo datasetGroupVo;
    UiPage<GdaiDatasetGroupVo> uiPage;
    try {
        EntityWrapper<GdaiDatasetGroup> wrapper = new EntityWrapper<GdaiDatasetGroup>();
        //tbd 数据集查看共享处理
        //            if (!CommonTools.isSuperAdminOrAiGroupAdmin(user)) {
        //                wrapper.eq("creator_id", userId);
        //            }
        wrapper.eq("data_type", dataType).eq("project_id", projectId).like(StringUtils.isNotBlank(datasetName), "dataset_name", datasetName).orderDesc(desc);
        Page<GdaiDatasetGroup> gdaiDatasetGroupPage = gdaiDatasetGroupService.selectPage(new Page<>(gdaiDatasetGroupVo.getPageNumber(), gdaiDatasetGroupVo.getPageCount()), wrapper);
        if ("pic".equalsIgnoreCase(dataType)) {
            if (gdaiDatasetGroupPage != null && gdaiDatasetGroupPage.getRecords().size() > 0) {
                List<GdaiDatasetGroup> records = gdaiDatasetGroupPage.getRecords();
                List<String> setDesc = new ArrayList<>();
                setDesc.add("dataset_version");
                List<GdaiDatasetVo> voList = null;
                for (GdaiDatasetGroup datasetGroup : records) {
                    datasetGroupVo = new GdaiDatasetGroupVo();
                    BeanUtils.copyProperties(datasetGroup, datasetGroupVo);
                    //获取数据集组ID
                    Long datasetGroupId = datasetGroup.getDatasetGroupId();
                    //根据数据集组ID查询该数据集组下所有数据集（为了便于页面交互默认只展示第一个数据集）
                    List<GdaiDataset> datasetList = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", datasetGroupId).orderDesc(setDesc));
                    if (datasetList != null && datasetList.size() > 0) {
                        GdaiDataset dataset = datasetList.get(0);
                        Long datasetId = dataset.getDatasetId();
                        //查询该数据集下所有文件个数（数据总量）
                        int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId));
                        //查询已标注的文件个数并计算百分比
                        int hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(datasetId);
                        String percentage = CalculateUtils.percentInstance(hasFlagCount, fileCount, 2);
                        GdaiDatasetVo datasetVo = new GdaiDatasetVo();
                        BeanUtils.copyProperties(dataset, datasetVo);
                        datasetVo.setFileCount(fileCount);
                        datasetVo.setHasFlagCount(hasFlagCount);
                        datasetVo.setPercentage(percentage);
                        voList = new ArrayList<>();
                        voList.add(datasetVo);
                        datasetGroupVo.setGdaiDatasetList(voList);
                    }
                    list.add(datasetGroupVo);
                }
            }
        } else if ("txt".equalsIgnoreCase(dataType)) {
            if (gdaiDatasetGroupPage != null && gdaiDatasetGroupPage.getRecords().size() > 0) {
                List<GdaiDatasetGroup> records = gdaiDatasetGroupPage.getRecords();
                List<String> setDesc = new ArrayList<>();
                setDesc.add("dataset_version");
                List<GdaiDatasetVo> voList = null;
                for (GdaiDatasetGroup datasetGroup : records) {
                    datasetGroupVo = new GdaiDatasetGroupVo();
                    BeanUtils.copyProperties(datasetGroup, datasetGroupVo);
                    //获取数据集组ID
                    Long datasetGroupId = datasetGroup.getDatasetGroupId();
                    //根据数据集组ID查询该数据集组下所有数据集（为了便于页面交互默认只展示第一个数据集）
                    List<GdaiDataset> datasetList = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", datasetGroupId).orderDesc(setDesc));
                    if (datasetList != null && datasetList.size() > 0) {
                        GdaiDataset dataset = datasetList.get(0);
                        Long datasetId = dataset.getDatasetId();
                        //查询该数据集下所有文件个数（数据总量）
                        int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId));
                        //查询已标注的文件个数并计算百分比
                        int hasFlagCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId).eq("mark_status", "2"));
                        String percentage = CalculateUtils.percentInstance(hasFlagCount, fileCount, 2);
                        GdaiDatasetVo datasetVo = new GdaiDatasetVo();
                        BeanUtils.copyProperties(dataset, datasetVo);
                        datasetVo.setFileCount(fileCount);
                        datasetVo.setHasFlagCount(hasFlagCount);
                        datasetVo.setPercentage(percentage);
                        voList = new ArrayList<>();
                        voList.add(datasetVo);
                        datasetGroupVo.setGdaiDatasetList(voList);
                    }
                    list.add(datasetGroupVo);
                }
            }
        } else if ("video".equalsIgnoreCase(dataType)) {
            if (gdaiDatasetGroupPage != null && gdaiDatasetGroupPage.getRecords().size() > 0) {
                List<GdaiDatasetGroup> records = gdaiDatasetGroupPage.getRecords();
                List<String> setDesc = new ArrayList<>();
                setDesc.add("dataset_version");
                List<GdaiDatasetVo> voList;
                for (GdaiDatasetGroup datasetGroup : records) {
                    datasetGroupVo = new GdaiDatasetGroupVo();
                    BeanUtils.copyProperties(datasetGroup, datasetGroupVo);
                    //获取数据集组ID
                    Long datasetGroupId = datasetGroup.getDatasetGroupId();
                    //根据数据集组ID查询该数据集组下所有数据集（为了便于页面交互默认只展示第一个数据集）
                    List<GdaiDataset> datasetList = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", datasetGroupId).orderDesc(setDesc));
                    if (datasetList != null && datasetList.size() > 0) {
                        GdaiDataset dataset = datasetList.get(0);
                        Long datasetId = dataset.getDatasetId();
                        //查询该数据集下所有文件个数（数据总量）
                        int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId));
                        //查询已标注的文件个数并计算百分比
                        int hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(datasetId);
                        String percentage = CalculateUtils.percentInstance(hasFlagCount, fileCount, 2);
                        GdaiDatasetVo datasetVo = new GdaiDatasetVo();
                        BeanUtils.copyProperties(dataset, datasetVo);
                        datasetVo.setFileCount(fileCount);
                        datasetVo.setHasFlagCount(hasFlagCount);
                        datasetVo.setPercentage(percentage);
                        voList = new ArrayList<>();
                        voList.add(datasetVo);
                        datasetGroupVo.setGdaiDatasetList(voList);
                    }
                    list.add(datasetGroupVo);
                }
            }
        } else {
            return RestResult.genFailResult("数据集类型错误");
        }
        uiPage = new UiPage<>();
        uiPage.setTotal(gdaiDatasetGroupPage.getTotal());
        uiPage.setPageSize(gdaiDatasetGroupPage.getSize());
        uiPage.setPages(gdaiDatasetGroupPage.getPages());
        uiPage.setPageNum(gdaiDatasetGroupPage.getCurrent());
        uiPage.setList(list);
    } catch (Exception e) {
        log.info("查询数据集异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
com.eshore.gdai.trainingcenter.util.CalculateUtils
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiDatasetGroupVo
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetGroupService gdaiDatasetGroupService;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为queryGroupById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryGroupById(Long datasetGroupId) throws TrainginCenterException {
    log.info("GdaiDatasetGroupServiceImpl.queryGroupById params: " + JSON.toJSONString(datasetGroupId));
    if (datasetGroupId == null) {
        return RestResult.genFailResult("数据集组ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatasetGroup gdaiDatasetGroup = checkRoleGdaiDatasetGroup(user, datasetGroupId);
    return RestResult.genSuccessResult(gdaiDatasetGroup);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(Long id) throws TrainginCenterException {
    log.info("GdaiDatasetGroupServiceImpl.delete params: {}", id);
    if (id == null) {
        return RestResult.genFailResult("数据集组ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDatasetGroup gdaiDatasetGroup = checkGdaiDatasetGroup(user, id);
    try {
        //刪除数据集组之前判断该数据集组下数据集是否处于标注中，若是标注中的数据集组不能删除
        List<GdaiDataset> datasetList = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", id));
        if (datasetList != null && datasetList.size() > 0) {
            for (GdaiDataset dataset : datasetList) {
                String annotationStatus = dataset.getAnnotationStatus();
                if ("S0R".equals(annotationStatus)) {
                    return RestResult.genFailResult("该数据集组下存在标注中的数据集");
                }
            }
        }
        //根据数据集组ID查询该组下所有数据集
        List<GdaiDataset> gdaiDatasetList = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", id));
        if (gdaiDatasetList != null && gdaiDatasetList.size() > 0) {
            for (GdaiDataset dataset : gdaiDatasetList) {
                //获取文件存储路径
                String datasetCephPath = dataset.getDatasetCephPath();
                Long datasetId = dataset.getDatasetId();
                gdaiDatasetMapper.delete(new EntityWrapper<GdaiDataset>().eq("dataset_id", datasetId));
                gdaiDatafileMapper.delete(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId));
                gdaiDatafileLabelMapper.delete(new EntityWrapper<GdaiDatafileLabel>().eq("dataset_id", datasetId));
                gdaiDatalabelMapper.delete(new EntityWrapper<GdaiDatalabel>().eq("dataset_id", datasetId));
                //删除数据集的同时删除存储的对应文件和其余表中数据
                if (StringUtils.isNotBlank(datasetCephPath)) {
                    FileUtil.deleteFile(new File(datasetCephPath));
                }
            }
        }
        gdaiDatasetGroupMapper.deleteById(id);
    } catch (Exception e) {
        log.info("删除数据集组异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.List
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiDatasetGroup gdaiDatasetGroup) throws TrainginCenterException {
    log.info("GdaiDatasetGroupServiceImpl.update params: " + JSON.toJSONString(gdaiDatasetGroup));
    Long datasetGroupId = gdaiDatasetGroup.getDatasetGroupId();
    String datasetName = gdaiDatasetGroup.getDatasetName();
    Long modifierId = gdaiDatasetGroup.getModifierId();
    if (datasetGroupId == null) {
        return RestResult.genFailResult("数据集组ID不能为空");
    }
    if (StringUtils.isBlank(datasetName)) {
        return RestResult.genFailResult("数据集组名称不能为空");
    }
    if (modifierId == null) {
        return RestResult.genFailResult("修改人不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //a b
    //修复水平越权问题
    GdaiDatasetGroup datasetGroup = checkGdaiDatasetGroup(user, datasetGroupId);
    try {
        //新增之前根据数据集名称查询看是否已存在该名称的数据集
        GdaiDatasetGroup datasetGroupExist = gdaiDatasetGroupService.selectOne(new EntityWrapper<GdaiDatasetGroup>().eq("dataset_name", datasetName).eq("creator_id", modifierId));
        if (datasetGroupExist != null) {
            return RestResult.genFailResult("该数据集名称已存在");
        }
        Date curDate = new Date();
        datasetGroup.setModifyTime(curDate);
        datasetGroup.setModifierId(user.getId());
        datasetGroup.setDatasetName(datasetName);
        gdaiDatasetGroupMapper.updateById(datasetGroup);
    } catch (Exception e) {
        log.info("修改数据集名称异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiDatasetGroupService gdaiDatasetGroupService;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为queryMarkDataset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryMarkDataset(GdaiDatasetGroupVo gdaiDatasetGroupVo) {
    log.info("GdaiDatasetGroupServiceImpl.queryMarkDataset params: " + JSON.toJSONString(gdaiDatasetGroupVo));
    Long projectId = gdaiDatasetGroupVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    List<GdaiDatasetGroupVo> datasetGroupVoList = new ArrayList<>();
    GdaiDatasetGroupVo groupVo;
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    try {
        EntityWrapper<GdaiDatasetGroup> wrapper = new EntityWrapper<GdaiDatasetGroup>();
        //tbd 数据集查看共享处理
        //            if (!CommonTools.isSuperAdminOrAiGroupAdmin(user)) {
        //                wrapper.eq("creator_id", userId);
        //            }
        wrapper.eq("project_id", projectId);
        wrapper.orderDesc(desc);
        List<GdaiDatasetGroup> datasetGroupList = gdaiDatasetGroupMapper.selectList(wrapper);
        if (datasetGroupList != null && datasetGroupList.size() > 0) {
            List<GdaiDatasetVo> datasetList;
            GdaiDatasetVo datasetVo;
            List<String> desc2 = new ArrayList<>();
            desc2.add("dataset_version");
            for (GdaiDatasetGroup datasetGroup : datasetGroupList) {
                groupVo = new GdaiDatasetGroupVo();
                BeanUtils.copyProperties(datasetGroup, groupVo);
                Long datasetGroupId = datasetGroup.getDatasetGroupId();
                List<GdaiDataset> list = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", datasetGroupId).orderDesc(desc2));
                if (list != null && list.size() > 0) {
                    datasetList = new ArrayList<>();
                    for (GdaiDataset dataset : list) {
                        datasetVo = new GdaiDatasetVo();
                        BeanUtils.copyProperties(dataset, datasetVo);
                        datasetList.add(datasetVo);
                    }
                    groupVo.setGdaiDatasetList(datasetList);
                    datasetGroupVoList.add(groupVo);
                }
            }
        }
        //对于初步筛选的数据集，查看该数据集下是否有可标注的数据
        if (datasetGroupVoList != null && datasetGroupVoList.size() > 0) {
            for (GdaiDatasetGroupVo datasetGroupVo : datasetGroupVoList) {
                List<GdaiDatasetVo> gdaiDatasetList = datasetGroupVo.getGdaiDatasetList();
                for (GdaiDatasetVo datasetVo : gdaiDatasetList) {
                    Long datasetId = datasetVo.getDatasetId();
                    //根据数据集ID查询该数据集目前是否关联了多人标注以及多人标注的任务状态（任务状态为2-待标注 3-标注中 4-标注完成（所有子任务状态都为已提交）则不可选）
                    int markJobCount = gdaiMarkJobMapper.selectCount(new EntityWrapper<GdaiMarkJob>().eq("dataset_id", datasetId).in("status", "2,3,4"));
                    if (markJobCount > 0) {
                        datasetVo.setMarkJobIsChecked("1");
                    } else {
                        datasetVo.setMarkJobIsChecked("0");
                    }
                    int isChecked = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("mark_status", "1"));
                    if (isChecked > 0) {
                        datasetVo.setIsChecked("1");
                    } else {
                        datasetVo.setIsChecked("0");
                    }
                    //将未标注的数量返回
                    datasetVo.setNoFlagCount(isChecked);
                }
            }
        }
    } catch (Exception e) {
        log.info("查询多人标注可选数据集列表异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(datasetGroupVoList);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiDatasetGroupVo
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为queryMarkDatasetByRole的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryMarkDatasetByRole(GdaiDatasetGroupVo gdaiDatasetGroupVo) {
    log.info("GdaiDatasetGroupServiceImpl.queryMarkDataset params: " + JSON.toJSONString(gdaiDatasetGroupVo));
    Long projectId = gdaiDatasetGroupVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    List<GdaiDatasetGroupVo> datasetGroupVoList = new ArrayList<>();
    GdaiDatasetGroupVo groupVo;
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    try {
        EntityWrapper<GdaiDatasetGroup> wrapper = new EntityWrapper<GdaiDatasetGroup>();
        //tbd 数据集查看共享处理
        if (!CommonTools.isSuperAdminOrAiGroupAdmin(user)) {
            wrapper.eq("creator_id", userId);
        }
        wrapper.eq("project_id", projectId);
        wrapper.orderDesc(desc);
        List<GdaiDatasetGroup> datasetGroupList = gdaiDatasetGroupMapper.selectList(wrapper);
        if (datasetGroupList != null && datasetGroupList.size() > 0) {
            List<GdaiDatasetVo> datasetList;
            GdaiDatasetVo datasetVo;
            List<String> desc2 = new ArrayList<>();
            desc2.add("dataset_version");
            for (GdaiDatasetGroup datasetGroup : datasetGroupList) {
                groupVo = new GdaiDatasetGroupVo();
                BeanUtils.copyProperties(datasetGroup, groupVo);
                Long datasetGroupId = datasetGroup.getDatasetGroupId();
                List<GdaiDataset> list = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", datasetGroupId).orderDesc(desc2));
                if (list != null && list.size() > 0) {
                    datasetList = new ArrayList<>();
                    for (GdaiDataset dataset : list) {
                        datasetVo = new GdaiDatasetVo();
                        BeanUtils.copyProperties(dataset, datasetVo);
                        datasetList.add(datasetVo);
                    }
                    groupVo.setGdaiDatasetList(datasetList);
                    datasetGroupVoList.add(groupVo);
                }
            }
        }
        //对于初步筛选的数据集，查看该数据集下是否有可标注的数据
        if (datasetGroupVoList != null && datasetGroupVoList.size() > 0) {
            for (GdaiDatasetGroupVo datasetGroupVo : datasetGroupVoList) {
                List<GdaiDatasetVo> gdaiDatasetList = datasetGroupVo.getGdaiDatasetList();
                for (GdaiDatasetVo datasetVo : gdaiDatasetList) {
                    Long datasetId = datasetVo.getDatasetId();
                    //根据数据集ID查询该数据集目前是否关联了多人标注以及多人标注的任务状态（任务状态为2-待标注 3-标注中 4-标注完成（所有子任务状态都为已提交）则不可选）
                    int markJobCount = gdaiMarkJobMapper.selectCount(new EntityWrapper<GdaiMarkJob>().eq("dataset_id", datasetId).in("status", "2,3,4"));
                    if (markJobCount > 0) {
                        datasetVo.setMarkJobIsChecked("1");
                    } else {
                        datasetVo.setMarkJobIsChecked("0");
                    }
                    int isChecked = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("mark_status", "1"));
                    if (isChecked > 0) {
                        datasetVo.setIsChecked("1");
                    } else {
                        datasetVo.setIsChecked("0");
                    }
                    //将未标注的数量返回
                    datasetVo.setNoFlagCount(isChecked);
                }
            }
        }
    } catch (Exception e) {
        log.info("查询多人标注可选数据集列表异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(datasetGroupVoList);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiDatasetGroupVo
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为queryTrainDataset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTrainDataset(GdaiDatasetGroupVo gdaiDatasetGroupVo) {
    log.info("GdaiDatasetGroupServiceImpl.queryTrainDataset params: " + JSON.toJSONString(gdaiDatasetGroupVo));
    Long projectId = gdaiDatasetGroupVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    List<GdaiDatasetGroupVo> datasetGroupVoList = new ArrayList<>();
    GdaiDatasetGroupVo groupVo;
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    try {
        EntityWrapper<GdaiDatasetGroup> wrapper = new EntityWrapper<GdaiDatasetGroup>();
        //tbd 数据集查看共享处理
        //            if (!CommonTools.isSuperAdminOrAiGroupAdmin(user)) {
        //                wrapper.eq("creator_id", userId);
        //            }
        wrapper.eq("project_id", projectId);
        wrapper.orderDesc(desc);
        List<GdaiDatasetGroup> datasetGroupList = gdaiDatasetGroupMapper.selectList(wrapper);
        if (datasetGroupList != null && datasetGroupList.size() > 0) {
            List<GdaiDatasetVo> datasetList;
            GdaiDatasetVo datasetVo;
            List<String> desc2 = new ArrayList<>();
            desc2.add("dataset_version");
            for (GdaiDatasetGroup datasetGroup : datasetGroupList) {
                groupVo = new GdaiDatasetGroupVo();
                BeanUtils.copyProperties(datasetGroup, groupVo);
                Long datasetGroupId = datasetGroup.getDatasetGroupId();
                List<GdaiDataset> list = gdaiDatasetMapper.selectList(new EntityWrapper<GdaiDataset>().eq("dataset_group_id", datasetGroupId).orderDesc(desc2));
                if (list != null && list.size() > 0) {
                    datasetList = new ArrayList<>();
                    for (GdaiDataset dataset : list) {
                        datasetVo = new GdaiDatasetVo();
                        BeanUtils.copyProperties(dataset, datasetVo);
                        datasetList.add(datasetVo);
                    }
                    groupVo.setGdaiDatasetList(datasetList);
                    datasetGroupVoList.add(groupVo);
                }
            }
        }
        //对于初步筛选的数据集，判断数据集数据量不为0的
        if (datasetGroupVoList != null && datasetGroupVoList.size() > 0) {
            for (GdaiDatasetGroupVo datasetGroupVo : datasetGroupVoList) {
                List<GdaiDatasetVo> gdaiDatasetList = datasetGroupVo.getGdaiDatasetList();
                for (GdaiDatasetVo datasetVo : gdaiDatasetList) {
                    Long datasetId = datasetVo.getDatasetId();
                    int isChecked = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId));
                    if (isChecked > 0) {
                        datasetVo.setIsChecked("1");
                    } else {
                        datasetVo.setIsChecked("0");
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("查询多人标注可选数据集列表异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(datasetGroupVoList);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetGroupService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiDatasetGroupVo
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为checkGdaiDatasetGroup的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiDatasetGroup checkGdaiDatasetGroup(User user, Long datasetGroupId) throws TrainginCenterException {
    GdaiDatasetGroup datasetGroup = gdaiDatasetGroupMapper.selectById(datasetGroupId);
    if (datasetGroup == null) {
        throw new TrainginCenterException("未查询到该数据集组信息");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(datasetGroup.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return datasetGroup;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
### 类级别的变量
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetGroupServiceImpl中有一个名为checkRoleGdaiDatasetGroup的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiDatasetGroup checkRoleGdaiDatasetGroup(User user, Long datasetGroupId) throws TrainginCenterException {
    GdaiDatasetGroup datasetGroup = gdaiDatasetGroupMapper.selectById(datasetGroupId);
    if (datasetGroup == null) {
        throw new TrainginCenterException("未查询到该数据集组信息");
    } else {
        //判断登录用户角色
        //判断登录用户角色
        boolean aiLabelOperRole = SessionUtils.isAiLabeloperRole(user);
        //AI模型开发员角色 aimodeldev
        boolean aiModelDevRole = SessionUtils.isAiModelDevRole(user);
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole || aiLabelOperRole || aiModelDevRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(datasetGroup.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return datasetGroup;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
### 类级别的变量
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为addNewVersion的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addNewVersion(GdaiDatasetVo gdaiDatasetVo) throws TrainginCenterException {
    log.info("GdaiDatasetServiceImpl.addNewVersion params: [{}]", JSON.toJSONString(gdaiDatasetVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long datasetGroupId = gdaiDatasetVo.getDatasetGroupId();
    Long datasetVersion = gdaiDatasetVo.getDatasetVersion();
    String extendHistoryVersion = gdaiDatasetVo.getExtendHistoryVersion();
    Long creatorId = gdaiDatasetVo.getCreatorId();
    String dataType = gdaiDatasetVo.getDataType();
    if (datasetGroupId == null) {
        return RestResult.genFailResult("数据组ID不能为空");
    }
    if (datasetVersion == null) {
        return RestResult.genFailResult("新版本号不能为空");
    }
    if (StringUtils.isBlank(extendHistoryVersion)) {
        return RestResult.genFailResult("是否继承历史版本标志不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    gdaiDatasetGroupService.checkGdaiDatasetGroup(user, datasetGroupId);
    GdaiDataset gdaiDataset;
    try {
        //如果extendHistoryVersion为0表示不需要继承历史版本
        if ("0".equals(extendHistoryVersion)) {
            gdaiDataset = copyDataset(gdaiDatasetVo, null, extendHistoryVersion, dataType);
        } else if ("1".equals(extendHistoryVersion)) {
            Long historyVersion = gdaiDatasetVo.getHistoryVersion();
            //根据数据集组ID和版本号查询该数据集信息
            GdaiDataset dataset = gdaiDatasetMapper.selectOne(new GdaiDataset(datasetGroupId, historyVersion));
            //根据旧数据集ID查询该数据集下是否有可以copy的文件信息
            int datafileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", dataset.getDatasetId()));
            if (datafileCount == 0) {
                return RestResult.genFailResult("所选历史版本为空数据集");
            }
            //拷贝之前查询要新增的数据集是否已存在
            GdaiDataset gdaiSet = gdaiDatasetMapper.selectOne(new GdaiDataset(datasetGroupId, datasetVersion));
            if (gdaiSet != null) {
                return RestResult.genFailResult("要新增的数据集已存在");
            }
            //拷贝旧数据集信息到新数据集
            gdaiDataset = copyDataset(gdaiDatasetVo, dataset, extendHistoryVersion, dataType);
            //获取新数据集ID，将新数据集导入状态修改为导入中-SOR
            Long newDatasetId = gdaiDataset.getDatasetId();
            GdaiDataset set = new GdaiDataset();
            set.setDatasetId(newDatasetId);
            set.setImpStatus("S0R");
            gdaiDatasetMapper.updateById(set);
            //另起线程处理数据集下相关数据拷贝操作
            GdaiDatasetServiceImpl gdaiDatasetServiceImpl = new GdaiDatasetServiceImpl();
            uploadThreadPool.execute(new GdaiDatasetServiceImpl.StartCopyDataset(transactionManager, transactionStatuses, gdaiDatasetMapper, gdaiDatafileMapper, gdaiDatalabelMapper, gdaiDatafileLabelMapper, sqlSessionTemplate, gdaiDatasetServiceImpl, gdaiDatasetVo, gdaiDataset));
        } else {
            return RestResult.genFailResult("是否继承历史版本标志错误");
        }
    } catch (Exception e) {
        log.info("新增新版本数据集异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult(gdaiDataset.getDatasetId());
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatasetService gdaiDatasetService;
@Resource
private GdaiDatasetGroupService gdaiDatasetGroupService;
@Resource
private SqlSessionTemplate sqlSessionTemplate;
@Resource
private HttpServletRequest request;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
@Resource
private PlatformTransactionManager transactionManager;
List<TransactionStatus> transactionStatuses = Collections.synchronizedList(new ArrayList<>());

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为queryAllDataset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAllDataset(GdaiDatasetVo gdaiDatasetVo) {
    log.info("GdaiDatasetServiceImpl.queryAllDataset params: [{}]", JSON.toJSONString(gdaiDatasetVo));
    Long datasetGroupId = gdaiDatasetVo.getDatasetGroupId();
    String dataType = gdaiDatasetVo.getDataType();
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    if (datasetGroupId == null) {
        return RestResult.genFailResult("数据组ID不能为空");
    }
    List<GdaiDatasetVo> list = new ArrayList<>();
    Page<GdaiDataset> gdaiDatasetPage;
    try {
        List<String> desc = new ArrayList<>();
        desc.add("dataset_version");
        GdaiDatasetVo datasetVo;
        EntityWrapper<GdaiDataset> wrapper = new EntityWrapper<GdaiDataset>();
        ////tbd 数据集查看共享处理
        //            if (!CommonTools.isSuperAdminOrAiGroupAdmin(user)) {
        //                wrapper.eq("creator_id", userId);
        //            }
        wrapper.eq("dataset_group_id", datasetGroupId).orderDesc(desc);
        gdaiDatasetPage = gdaiDatasetService.selectPage(new Page<>(gdaiDatasetVo.getPageNumber(), gdaiDatasetVo.getPageCount()), wrapper);
        if (gdaiDatasetPage != null && gdaiDatasetPage.getRecords().size() > 0) {
            List<GdaiDataset> records = gdaiDatasetPage.getRecords();
            for (GdaiDataset dataset : records) {
                Long datasetId = dataset.getDatasetId();
                //查询该数据集下所有文件个数（数据总量）
                int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId));
                //查询已标注的文件个数并计算百分比
                int hasFlagCount;
                if ("pic".equalsIgnoreCase(dataType)) {
                    hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(datasetId);
                } else if ("txt".equalsIgnoreCase(dataType)) {
                    //hasFlagCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId).eq("mark_status", "1"));
                    List<String> hasMarkList = new ArrayList<>();
                    hasMarkList.add("2");
                    hasMarkList.add("3");
                    hasFlagCount = gdaiDatafileMapper.queryAllFileNum(datasetId, hasMarkList);
                } else if ("video".equalsIgnoreCase(dataType)) {
                    hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(datasetId);
                } else {
                    return RestResult.genFailResult("数据集类型错误");
                }
                String percentage = CalculateUtils.percentInstance(hasFlagCount, fileCount, 2);
                datasetVo = new GdaiDatasetVo();
                BeanUtils.copyProperties(dataset, datasetVo);
                datasetVo.setFileCount(fileCount);
                datasetVo.setHasFlagCount(hasFlagCount);
                datasetVo.setPercentage(percentage);
                list.add(datasetVo);
            }
        }
    } catch (Exception e) {
        log.info("查询所有版本数据集异常", e);
        return RestResult.genFailResult("查询异常");
    }
    UiPage<GdaiDatasetVo> uiPage = new UiPage<>();
    uiPage.setTotal(gdaiDatasetPage.getTotal());
    uiPage.setPageSize(gdaiDatasetPage.getSize());
    uiPage.setPages(gdaiDatasetPage.getPages());
    uiPage.setPageNum(gdaiDatasetPage.getCurrent());
    uiPage.setList(list);
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
com.eshore.gdai.trainingcenter.util.CalculateUtils
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetService gdaiDatasetService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiDataset gdaiDataset) throws TrainginCenterException {
    log.info("GdaiDatasetServiceImpl.update params: " + JSON.toJSONString(gdaiDataset));
    Long datasetId = gdaiDataset.getDatasetId();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDataset dataset = checkGdaiDataset(user, datasetId);
    try {
        BeanUtils.copyProperties(gdaiDataset, dataset);
        Date curDate = new Date();
        dataset.setModifyTime(curDate);
        dataset.setModifierId(user.getId());
        gdaiDatasetMapper.updateById(dataset);
    } catch (Exception e) {
        log.info("修改数据集名称异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(Long id) throws TrainginCenterException {
    log.info("GdaiDatasetServiceImpl.delete params: {}", id);
    if (id == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDataset dataset = checkGdaiDataset(user, id);
    try {
        //根据数据集ID查询该数据集是否存在
        //            GdaiDataset dataset = gdaiDatasetMapper.selectById(id);
        //            if (dataset == null) {
        //                return RestResult.genFailResult("该数据集不存在");
        //            }
        //如果该数据集处于标注中状态则提示不能删除
        String annotationStatus = dataset.getAnnotationStatus();
        if ("S0R".equals(annotationStatus)) {
            return RestResult.genFailResult("该数据集处于标注中状态");
        }
        //获取文件存储路径
        String datasetCephPath = dataset.getDatasetCephPath();
        gdaiDatasetService.deleteById(id);
        gdaiDatafileMapper.delete(new EntityWrapper<GdaiDatafile>().eq("dataset_id", id));
        gdaiDatafileLabelMapper.delete(new EntityWrapper<GdaiDatafileLabel>().eq("dataset_id", id));
        gdaiDatalabelMapper.delete(new EntityWrapper<GdaiDatalabel>().eq("dataset_id", id));
        //删除数据集的同时删除存储的对应文件和其余表中数据
        if (StringUtils.isNotBlank(datasetCephPath)) {
            FileUtil.deleteFile(new File(datasetCephPath));
        }
    } catch (Exception e) {
        log.info("删除数据集异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatasetService gdaiDatasetService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为queryDatasetInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryDatasetInfo(Long id) throws TrainginCenterException {
    log.info("GdaiDatasetServiceImpl.queryDatasetInfo params: [{}]", id);
    if (id == null) {
        return RestResult.genFailResult("查询ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDataset dataset = checkGdaiDataset(user, id);
    GdaiDatasetVo gdaiDatasetVo = new GdaiDatasetVo();
    try {
        //根据数据集ID反查该数据集类型
        //            GdaiDataset dataset = gdaiDatasetMapper.selectById(id);
        //            if (dataset == null) {
        //                return RestResult.genFailResult("该数据集不存在");
        //            }
        //再根据数据集组ID差反查出数据集类型
        Long datasetGroupId = dataset.getDatasetGroupId();
        GdaiDatasetGroup gdaiDatasetGroup = gdaiDatasetGroupMapper.selectById(datasetGroupId);
        if (gdaiDatasetGroup == null) {
            return RestResult.genFailResult("该数据集组不存在");
        }
        String dataType = gdaiDatasetGroup.getDataType();
        //查询该数据集下所有文件个数（数据总量）
        int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(id != null, "dataset_id", id));
        int hasFlagCount = 0;
        if ("pic".equalsIgnoreCase(dataType)) {
            //查询数据集下标注框数
            int frameCount = gdaiDatafileLabelMapper.selectCount(new EntityWrapper<GdaiDatafileLabel>().eq(id != null, "dataset_id", id).isNotNull("label_data"));
            gdaiDatasetVo.setFrameCount(frameCount);
            //查询已标注的文件个数并计算百分比
            hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(id);
        } else if ("txt".equalsIgnoreCase(dataType)) {
            //hasFlagCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(id != null, "dataset_id", id).eq("mark_status", "2"));
            List<String> hasMarkList = new ArrayList<>();
            hasMarkList.add("2");
            hasMarkList.add("3");
            hasFlagCount = gdaiDatafileMapper.queryAllFileNum(id, hasMarkList);
        } else if ("video".equalsIgnoreCase(dataType)) {
            //查询数据集下标注框数
            int frameCount = gdaiDatafileLabelMapper.selectCount(new EntityWrapper<GdaiDatafileLabel>().eq(id != null, "dataset_id", id).isNotNull("label_data"));
            gdaiDatasetVo.setFrameCount(frameCount);
            //查询已标注的文件个数并计算百分比
            hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(id);
        } else {
            return RestResult.genFailResult("数据集类型错误");
        }
        String percentage = percentInstance(hasFlagCount, fileCount, 2);
        //查询数据集下标签个数
        int labelCount = gdaiDatalabelMapper.selectCount(new EntityWrapper<GdaiDatalabel>().eq(id != null, "dataset_id", id));
        //查询待确认个数
        int confirmCount = gdaiDatafileMapper.queryConfirmStatus(id, "0");
        //查询数据集下所有文件大小
        Integer sum = gdaiDatafileMapper.querySumSize(id);
        String fileSize = getSize(sum == null ? 0 : sum);
        gdaiDatasetVo.setFileCount(fileCount);
        gdaiDatasetVo.setHasFlagCount(hasFlagCount);
        gdaiDatasetVo.setPercentage(percentage);
        gdaiDatasetVo.setLabelCount(labelCount);
        gdaiDatasetVo.setConfirmCount(confirmCount);
        gdaiDatasetVo.setFileSize(fileSize);
    } catch (Exception e) {
        log.info("查询数据集信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiDatasetVo);
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.springframework.stereotype.Service
java.io.File
java.util.ArrayList
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为downloadMould的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Object downloadMould(String dataType) {
    log.info("GdaiDatasetServiceImpl.downloadMould params: [{}]", dataType);
    ResponseEntity<InputStreamResource> response = null;
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    try {
        String route;
        String fileName;
        String newName;
        if ("PIC".equals(dataType)) {
            route = "static" + File.separator + "pic" + File.separator;
            //文件名
            fileName = "pic_sample.zip";
            newName = "pic_sample";
        } else if ("TXT".equals(dataType)) {
            route = "static" + File.separator + "txt" + File.separator;
            //文件名
            fileName = "txt_sample.zip";
            newName = "txt_sample";
        } else {
            return RestResult.genFailResult("数据集类型错误");
        }
        response = DownloadFileUtil.download(route, StringUtils.EMPTY, fileName, newName);
    } catch (Exception e) {
        log.error("下载模板异常", e);
        RestResult.genSuccessResult("下载模板异常");
    }
    return response;
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
com.eshore.gdai.trainingcenter.util.DownloadFileUtil
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.lang3.StringUtils
org.springframework.core.io.InputStreamResource
org.springframework.http.ResponseEntity
org.springframework.stereotype.Service
javax.annotation.Resource
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为downloadDataset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadDataset(Long datasetId, HttpServletResponse response, HttpServletRequest request) throws TrainginCenterException {
    log.info("GdaiDatasetServiceImpl.downloadDataset params: [{}]", datasetId);
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDataset dataset = checkGdaiDataset(user, datasetId);
    try {
        //根据数据集ID查询该数据集是否存在
        //            GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
        //            if (dataset == null) {
        //                return RestResult.genFailResult("该数据集不存在");
        //            }
        //获取已标注文件存储路径
        String datasetFilePath = dataset.getDatasetFilePath();
        if (StringUtils.isBlank(datasetFilePath)) {
            return RestResult.genFailResult("路径为空");
        }
        String filesPath = datasetFilePath.substring(0, datasetFilePath.lastIndexOf("files"));
        String fileName = "datasets";
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(filesPath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
com.eshore.gdai.trainingcenter.util.ZipUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为queryMaxVersion的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryMaxVersion(Long datasetGroupId) {
    log.info("GdaiDatasetServiceImpl.queryMaxVersion params: [{}]", datasetGroupId);
    if (datasetGroupId == null) {
        return RestResult.genFailResult("数据集组ID不能为空");
    }
    Integer maxVersion;
    try {
        maxVersion = gdaiDatasetMapper.queryMaxVersion(datasetGroupId);
    } catch (Exception e) {
        log.info("查询数据集最大版本号异常", e);
        return RestResult.genFailResult("查询成功");
    }
    return RestResult.genSuccessResult(maxVersion == null ? 0 : maxVersion);
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
org.springframework.stereotype.Service
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为queryDatasetGroup的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryDatasetGroup(Long datasetId) throws TrainginCenterException {
    log.info("GdaiDatasetServiceImpl.queryDatasetGroup params: [{}]", datasetId);
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDataset gdaiDataset = checkRoleGdaiDataset(user, datasetId);
    GdaiDatasetVo gdaiDatasetVo;
    try {
        Long datasetGroupId = gdaiDataset.getDatasetGroupId();
        GdaiDatasetGroup gdaiDatasetGroup = gdaiDatasetGroupMapper.selectById(datasetGroupId);
        //查询该数据集下所有文件个数（数据总量）
        int fileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq(datasetId != null, "dataset_id", datasetId));
        //查询已标注的文件个数并计算百分比
        int hasFlagCount = gdaiDatafileLabelMapper.queryFlagCount(datasetId);
        String percentage = CalculateUtils.percentInstance(hasFlagCount, fileCount, 2);
        gdaiDatasetVo = new GdaiDatasetVo();
        BeanUtils.copyProperties(gdaiDataset, gdaiDatasetVo);
        gdaiDatasetVo.setDatasetName(gdaiDatasetGroup.getDatasetName());
        gdaiDatasetVo.setDataType(gdaiDatasetGroup.getDataType());
        gdaiDatasetVo.setFileCount(fileCount);
        gdaiDatasetVo.setHasFlagCount(hasFlagCount);
        gdaiDatasetVo.setPercentage(percentage);
    } catch (Exception e) {
        log.info("查询数据集组名称及版本异常", e);
        return RestResult.genFailResult("查询成功");
    }
    return RestResult.genSuccessResult(gdaiDatasetVo);
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.service.GdaiDatasetService
com.eshore.gdai.trainingcenter.util.CalculateUtils
com.eshore.gdai.trainingcenter.vo.GdaiDatasetVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.io.File
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为percentInstance的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 百分比计算
     *
     * @param detailTotalNumber
     * @param totalNumber
     * @return
     */
public String percentInstance(Integer detailTotalNumber, Integer totalNumber, Integer min) {
    Double fileCount = Double.valueOf(detailTotalNumber);
    Double hasFlagCount = Double.valueOf(totalNumber);
    double percent;
    if (detailTotalNumber == 0 && totalNumber == 0) {
        percent = 0;
    } else {
        percent = fileCount / hasFlagCount;
    }
    //获取格式化对象
    NumberFormat nt = NumberFormat.getPercentInstance();
    //设置百分数精确度2即保留两位小数
    nt.setMinimumFractionDigits(min);
    return nt.format(percent);
}
### 类导入的包
java.text.NumberFormat
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为getSize的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据大小转换成对应单位
     *
     * @param size
     * @return
     */
public String getSize(long size) {
    StringBuffer bytes = new StringBuffer();
    DecimalFormat format = new DecimalFormat("###.0");
    if (size >= 1024 * 1024 * 1024) {
        double i = (size / (1024.0 * 1024.0 * 1024.0));
        bytes.append(format.format(i)).append("GB");
    } else if (size >= 1024 * 1024) {
        double i = (size / (1024.0 * 1024.0));
        bytes.append(format.format(i)).append("MB");
    } else if (size >= 1024) {
        double i = (size / (1024.0));
        bytes.append(format.format(i)).append("KB");
    } else if (size < 1024) {
        if (size <= 0) {
            bytes.append("0B");
        } else {
            bytes.append((int) size).append("B");
        }
    }
    return bytes.toString();
}
### 类导入的包
java.text.DecimalFormat
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为copyDataset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param datasetVo
     * @param dataset
     * @param extendHistoryVersion
     * @param dataType
     * @return
     */
public GdaiDataset copyDataset(GdaiDatasetVo datasetVo, GdaiDataset dataset, String extendHistoryVersion, String dataType) throws Exception {
    Date curDate = new Date();
    GdaiDataset gdaiDataset = new GdaiDataset();
    if ("0".equals(extendHistoryVersion)) {
        BeanUtils.copyProperties(datasetVo, gdaiDataset);
    } else if ("1".equals(extendHistoryVersion)) {
        BeanUtils.copyProperties(dataset, gdaiDataset);
        gdaiDataset.setDatasetVersion(datasetVo.getDatasetVersion());
        gdaiDataset.setExtendHistoryVersion("1");
        gdaiDataset.setHistoryVersion(datasetVo.getHistoryVersion());
        gdaiDataset.setRemarks(datasetVo.getRemarks());
    } else {
        throw new Exception("是否继承历史版本标识错误");
    }
    //新版本数据集标注状态初始化为：S0N-未标注
    gdaiDataset.setAnnotationStatus("S0N");
    gdaiDataset.setCreateTime(curDate);
    gdaiDataset.setModifyTime(curDate);
    gdaiDatasetMapper.insert(gdaiDataset);
    //获取数据集ID
    Long datasetId = gdaiDataset.getDatasetId();
    //拼装存储路径
    String datasetCephPath;
    String datasetFilePath;
    String datasetLabelPath;
    if ("pic".equalsIgnoreCase(dataType)) {
        datasetCephPath = cephUploadPath + picDataset + "/" + datasetId;
        datasetFilePath = cephUploadPath + picDataset + "/" + datasetId + "/datasets/files/";
        datasetLabelPath = cephUploadPath + picDataset + "/" + datasetId + "/datasets/labels/";
    } else if ("txt".equalsIgnoreCase(dataType)) {
        datasetCephPath = cephUploadPath + txtDataset + "/" + datasetId;
        datasetFilePath = cephUploadPath + picDataset + "/" + datasetId + "/datasets/files/";
        datasetLabelPath = cephUploadPath + picDataset + "/" + datasetId + "/datasets/labels/";
    } else if ("video".equalsIgnoreCase(dataType)) {
        datasetCephPath = cephUploadPath + videoDataset + "/" + datasetId;
        datasetFilePath = cephUploadPath + videoDataset + "/" + datasetId + "/datasets/files/";
        datasetLabelPath = cephUploadPath + videoDataset + "/" + datasetId + "/datasets/labels/";
    } else {
        throw new Exception("数据集类型错误");
    }
    //创建对应目录
    FileUtil.createDir(datasetFilePath);
    FileUtil.createDir(datasetLabelPath);
    //根据ID设置该字段
    gdaiDataset.setDatasetCephPath(datasetCephPath);
    gdaiDataset.setDatasetFilePath(datasetFilePath);
    gdaiDataset.setDatasetLabelPath(datasetLabelPath);
    gdaiDataset.setDatasetId(datasetId);
    gdaiDatasetMapper.updateById(gdaiDataset);
    return gdaiDataset;
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.util.FileUtil
org.springframework.beans.BeanUtils
java.io.File
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * 数据集存放图片目录
 */
@Value("${cephUpload.picDataset}")
private String picDataset;
/**
 * 数据集存放文本目录
 */
@Value("${cephUpload.txtDataset}")
private String txtDataset;
/**
 * 数据集存放视频目录
 */
@Value("${cephUpload.videoDataset}")
private String videoDataset;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为copyDataFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param oldDatasetId
     * @param gdaiDataset
     * @param batchCount
     * @return
     */
public Map<Long, Long> copyDataFile(GdaiDatafileMapper gdaiDatafileMapper, Long oldDatasetId, GdaiDataset gdaiDataset, int batchCount, String dataType) {
    //该map用来存放新旧对应ID
    Map<Long, Long> dataFileMapping = null;
    Long newDatasetId = gdaiDataset.getDatasetId();
    String datasetCephPath = gdaiDataset.getDatasetCephPath();
    //根据旧版本数据集ID查询该数据集下所有文本信息
    int datafileCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", oldDatasetId));
    if (datafileCount > 0) {
        dataFileMapping = new HashMap<>();
        //该变量为需要执行的批次数
        int fileBatchSize = datafileCount / batchCount;
        //该集合存放临时要插入的数据
        List<GdaiDatafile> list;
        //起始值
        int fileIndex = 0;
        //该变量表示实际执行循环次数
        int i = 0;
        Date date = new Date();
        for (; fileIndex < datafileCount; ) {
            if (i < fileBatchSize) {
                List<GdaiDatafileVo> datafileList = gdaiDatafileMapper.queryFileByPage(new GdaiDatafileVo(oldDatasetId, fileIndex, batchCount));
                if (datafileList != null && datafileList.size() > 0) {
                    list = new ArrayList<>();
                    for (GdaiDatafileVo datafileVo : datafileList) {
                        GdaiDatafile datafile = new GdaiDatafile();
                        BeanUtils.copyProperties(datafileVo, datafile);
                        datafile.setCephUrl(datasetCephPath + "/source/" + datafileVo.getFileName());
                        if ("pic".equalsIgnoreCase(dataType)) {
                            datafile.setIconUrl(datasetCephPath + "/thumb/" + "thumb_" + datafileVo.getFileName());
                        } else if ("video".equalsIgnoreCase(dataType)) {
                            String fileName = datafileVo.getFileName();
                            int dotIndex = fileName.lastIndexOf('.');
                            if (dotIndex != -1) {
                                String nameWithoutExtension = fileName.substring(0, dotIndex);
                                datafile.setIconUrl(datasetCephPath + "/thumb/" + "thumb_" + nameWithoutExtension + ".jpg");
                            } else {
                                log.info("文件名没有扩展名");
                            }
                        }
                        datafile.setDatasetId(newDatasetId);
                        datafile.setFileData(StringUtils.isNotBlank(datafileVo.getFileData()) ? datafileVo.getFileData() : " ");
                        datafile.setCreateTime(date);
                        datafile.setModifyTime(date);
                        list.add(datafile);
                        //插入新数据
                        gdaiDatafileMapper.insert(datafile);
                        //将新旧文件ID对应关系存储在map中
                        dataFileMapping.put(datafileVo.getDatafileId(), datafile.getDatafileId());
                    }
                }
                log.info("datafile copy, fileIndex:" + fileIndex + " batchCount:" + batchCount);
                // 设置下一批下标
                fileIndex = fileIndex + batchCount;
            } else {
                List<GdaiDatafileVo> datafileList = gdaiDatafileMapper.queryFileByPage(new GdaiDatafileVo(oldDatasetId, fileIndex, batchCount));
                //获取文件ID执行批量插入
                if (datafileList != null && datafileList.size() > 0) {
                    list = new ArrayList<>();
                    for (GdaiDatafileVo datafileVo : datafileList) {
                        GdaiDatafile datafile = new GdaiDatafile();
                        BeanUtils.copyProperties(datafileVo, datafile);
                        datafile.setCephUrl(datasetCephPath + "/source/" + datafileVo.getFileName());
                        if ("pic".equalsIgnoreCase(dataType)) {
                            datafile.setIconUrl(datasetCephPath + "/thumb/" + "thumb_" + datafileVo.getFileName());
                        } else if ("video".equalsIgnoreCase(dataType)) {
                            String fileName = datafileVo.getFileName();
                            int dotIndex = fileName.lastIndexOf('.');
                            if (dotIndex != -1) {
                                String nameWithoutExtension = fileName.substring(0, dotIndex);
                                datafile.setIconUrl(datasetCephPath + "/thumb/" + "thumb_" + nameWithoutExtension + ".jpg");
                            } else {
                                log.info("文件名没有扩展名");
                            }
                        }
                        datafile.setDatasetId(newDatasetId);
                        datafile.setFileData(StringUtils.isNotBlank(datafileVo.getFileData()) ? datafileVo.getFileData() : " ");
                        datafile.setCreateTime(date);
                        datafile.setModifyTime(date);
                        list.add(datafile);
                        //插入新数据
                        gdaiDatafileMapper.insert(datafile);
                        //将新旧文件ID对应关系存储在map中
                        dataFileMapping.put(datafileVo.getDatafileId(), datafile.getDatafileId());
                    }
                }
                log.info("datafile copy, fileIndex:" + fileIndex + " batchCount:" + batchCount);
                fileIndex = fileIndex + batchCount;
            }
            i++;
        }
    }
    return dataFileMapping;
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
java.io.File
java.util.ArrayList
java.util.Date
java.util.HashMap
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为copyDataLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param oldDatasetId
     * @param gdaiDataset
     * @param batchCount
     * @return
     */
public Map<Long, Long> copyDataLabel(GdaiDatalabelMapper gdaiDatalabelMapper, Long oldDatasetId, GdaiDataset gdaiDataset, int batchCount) {
    //该map用来存放新旧对应ID
    Map<Long, Long> dataLabelMapping = null;
    Long newDatasetId = gdaiDataset.getDatasetId();
    //根据旧数据集ID查询该数据集下标签总数量
    int datalabelCount = gdaiDatalabelMapper.selectCount(new EntityWrapper<GdaiDatalabel>().eq("dataset_id", oldDatasetId));
    if (datalabelCount > 0) {
        dataLabelMapping = new HashMap<>();
        //该变量为需要执行的批次数
        int labelBatchSize = datalabelCount / batchCount;
        //该集合存放临时要插入的数据
        List<GdaiDatalabel> labelList;
        //起始值
        int labelIndex = 0;
        //该变量表示实际执行循环次数
        int j = 0;
        Date date = new Date();
        for (; labelIndex < datalabelCount; ) {
            if (j < labelBatchSize) {
                List<GdaiDatalabelVo> datalabelList = gdaiDatalabelMapper.queryLabelByPage(new GdaiDatalabelVo(oldDatasetId, labelIndex, batchCount));
                if (datalabelList != null && datalabelList.size() > 0) {
                    labelList = new ArrayList<>();
                    for (GdaiDatalabelVo datalabelVo : datalabelList) {
                        GdaiDatalabel datalabel = new GdaiDatalabel();
                        BeanUtils.copyProperties(datalabelVo, datalabel);
                        datalabel.setDatasetId(newDatasetId);
                        datalabel.setCreateTime(date);
                        datalabel.setModifyTime(date);
                        labelList.add(datalabel);
                        //执行插入操作
                        gdaiDatalabelMapper.insert(datalabel);
                        //将新旧标签ID对应关系存储在map中
                        dataLabelMapping.put(datalabelVo.getDatalabelId(), datalabel.getDatalabelId());
                    }
                }
                log.info("datalabel copy, labelIndex:" + labelIndex + " batchCount:" + batchCount);
                // 设置下一批下标
                labelIndex = labelIndex + batchCount;
            } else {
                List<GdaiDatalabelVo> datalabelList = gdaiDatalabelMapper.queryLabelByPage(new GdaiDatalabelVo(oldDatasetId, labelIndex, batchCount));
                if (datalabelList != null && datalabelList.size() > 0) {
                    labelList = new ArrayList<>();
                    for (GdaiDatalabelVo datalabelVo : datalabelList) {
                        GdaiDatalabel datalabel = new GdaiDatalabel();
                        BeanUtils.copyProperties(datalabelVo, datalabel);
                        datalabel.setDatasetId(newDatasetId);
                        datalabel.setCreateTime(date);
                        datalabel.setModifyTime(date);
                        labelList.add(datalabel);
                        //执行插入操作
                        gdaiDatalabelMapper.insert(datalabel);
                        //将新旧标签ID对应关系存储在map中
                        dataLabelMapping.put(datalabelVo.getDatalabelId(), datalabel.getDatalabelId());
                    }
                }
                log.info("datalabel copy, labelIndex:" + labelIndex + " batchCount:" + batchCount);
                // 设置下一批下标
                labelIndex = labelIndex + batchCount;
            }
            j++;
        }
    }
    return dataLabelMapping;
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
com.eshore.gdai.trainingcenter.vo.GdaiDatalabelVo
org.springframework.beans.BeanUtils
java.util.ArrayList
java.util.Date
java.util.HashMap
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为copyDataFileLabel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param oldDatasetId
     * @param gdaiDataset
     * @param dataFileMapping
     * @param dataLabelMapping
     * @param batchCount
     */
public void copyDataFileLabel(GdaiDatafileLabelMapper gdaiDatafileLabelMapper, SqlSessionTemplate sqlSessionTemplate, Long oldDatasetId, GdaiDataset gdaiDataset, Map<Long, Long> dataFileMapping, Map<Long, Long> dataLabelMapping, int batchCount) throws Exception {
    // 获取批量方式的sqlsession
    SqlSession batchSqlSession = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);
    try {
        Long newDatasetId = gdaiDataset.getDatasetId();
        //根据旧数据集ID查询该数据集下坐标信息总数量
        int datafileLabelCount = gdaiDatafileLabelMapper.selectCount(new EntityWrapper<GdaiDatafileLabel>().eq("dataset_id", oldDatasetId));
        if (datafileLabelCount > 0) {
            int result = 1;
            //该变量为需要执行的批次数
            int fileLabelBatchSize = datafileLabelCount / batchCount;
            //该集合存放临时要插入的数据
            List<GdaiDatafileLabel> fileLabelList;
            //起始值
            int fileLabelIndex = 0;
            //该变量表示实际执行循环次数
            int k = 0;
            Date date = new Date();
            for (; fileLabelIndex < datafileLabelCount; ) {
                if (k < fileLabelBatchSize) {
                    List<GdaiDatafileLabelVo> datafileLabelList = gdaiDatafileLabelMapper.queryDataFileLabelByPage(new GdaiDatafileLabelVo(oldDatasetId, fileLabelIndex, batchCount));
                    if (datafileLabelList != null && datafileLabelList.size() > 0) {
                        fileLabelList = new ArrayList<>();
                        for (GdaiDatafileLabelVo datafileLabeVo : datafileLabelList) {
                            GdaiDatafileLabel ddaiDatafileLabel = new GdaiDatafileLabel();
                            BeanUtils.copyProperties(datafileLabeVo, ddaiDatafileLabel);
                            //根据对映关系找出新的ID
                            Long oldDatafileId = datafileLabeVo.getDatafileId();
                            Long newDatafileId = dataFileMapping.get(oldDatafileId);
                            Long oldDatalabelId = datafileLabeVo.getDatalabelId();
                            Long newDatalabelId = dataLabelMapping.get(oldDatalabelId);
                            ddaiDatafileLabel.setLabelData(datafileLabeVo.getLabelData());
                            ddaiDatafileLabel.setDatafileId(newDatafileId);
                            ddaiDatafileLabel.setDatalabelId(newDatalabelId);
                            ddaiDatafileLabel.setDatasetId(newDatasetId);
                            ddaiDatafileLabel.setCreateTime(date);
                            ddaiDatafileLabel.setModifyTime(date);
                            fileLabelList.add(ddaiDatafileLabel);
                        }
                        result = result * batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelMapper.addDataFileLabelBatch", fileLabelList);
                        batchSqlSession.commit();
                    }
                    log.info("datafilelabel copy, fileLabelIndex:" + fileLabelIndex + " batchCount:" + batchCount);
                    // 设置下一批下标
                    fileLabelIndex = fileLabelIndex + batchCount;
                } else {
                    List<GdaiDatafileLabelVo> datafileLabelList = gdaiDatafileLabelMapper.queryDataFileLabelByPage(new GdaiDatafileLabelVo(oldDatasetId, fileLabelIndex, batchCount));
                    if (datafileLabelList != null && datafileLabelList.size() > 0) {
                        fileLabelList = new ArrayList<>();
                        for (GdaiDatafileLabelVo datafileLabeVo : datafileLabelList) {
                            GdaiDatafileLabel ddaiDatafileLabel = new GdaiDatafileLabel();
                            BeanUtils.copyProperties(datafileLabeVo, ddaiDatafileLabel);
                            //根据对映关系找出新的ID
                            Long oldDatafileId = datafileLabeVo.getDatafileId();
                            Long newDatafileId = dataFileMapping.get(oldDatafileId);
                            Long oldDatalabelId = datafileLabeVo.getDatalabelId();
                            Long newDatalabelId = dataLabelMapping.get(oldDatalabelId);
                            ddaiDatafileLabel.setLabelData(datafileLabeVo.getLabelData());
                            ddaiDatafileLabel.setDatafileId(newDatafileId);
                            ddaiDatafileLabel.setDatalabelId(newDatalabelId);
                            ddaiDatafileLabel.setDatasetId(newDatasetId);
                            ddaiDatafileLabel.setCreateTime(date);
                            ddaiDatafileLabel.setModifyTime(date);
                            fileLabelList.add(ddaiDatafileLabel);
                        }
                        result = result * batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelMapper.addDataFileLabelBatch", fileLabelList);
                        batchSqlSession.commit();
                    }
                    log.info("datafilelabel copy, fileLabelIndex:" + fileLabelIndex + " batchCount:" + batchCount);
                    // 设置下一批下标
                    fileLabelIndex = fileLabelIndex + batchCount;
                }
                k++;
            }
            //进行事务提交
            batchSqlSession.commit();
            batchSqlSession.clearCache();
        }
    } catch (Exception e) {
        batchSqlSession.rollback();
        throw new Exception("拷贝坐标信息异常");
    } finally {
        if (batchSqlSession != null) {
            batchSqlSession.close();
        }
    }
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelMapper
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
org.apache.ibatis.session.ExecutorType
org.apache.ibatis.session.SqlSession
org.springframework.beans.BeanUtils
java.io.File
java.util.ArrayList
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为checkGdaiDataset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiDataset checkGdaiDataset(User user, Long datasetId) throws TrainginCenterException {
    GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
    if (dataset == null) {
        throw new TrainginCenterException("未查询到该数据集信息");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(dataset.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return dataset;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDatasetServiceImpl中有一个名为checkRoleGdaiDataset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiDataset checkRoleGdaiDataset(User user, Long datasetId) throws TrainginCenterException {
    GdaiDataset dataset = gdaiDatasetMapper.selectById(datasetId);
    if (dataset == null) {
        throw new TrainginCenterException("未查询到该数据集信息");
    } else {
        //判断登录用户角色
        //AI数据标注员角色 ailabeloper
        boolean aiLabelOperRole = SessionUtils.isAiLabeloperRole(user);
        //AI模型开发员角色 aimodeldev
        boolean aiModelDevRole = SessionUtils.isAiModelDevRole(user);
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole || aiLabelOperRole || aiModelDevRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(dataset.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return dataset;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
java.util.Map
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为addDevModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addDevModel(GdaiDevModelVo gdaiDevModelVo) {
    log.info("GdaiDevModelServiceImpl.addDevModel params: [{}]", JSON.toJSONString(gdaiDevModelVo));
    GdaiDevModel gdaiDevModel = new GdaiDevModel();
    BeanUtils.copyProperties(gdaiDevModelVo, gdaiDevModel);
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long projectId = gdaiDevModelVo.getProjectId();
    Long imageId = gdaiDevModelVo.getImageId();
    String shareFlag = gdaiDevModelVo.getShareFlag();
    String core = gdaiDevModelVo.getCore();
    String memorySize = gdaiDevModelVo.getMemorySize();
    String gpuSize = gdaiDevModelVo.getGpuSize();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (imageId == null) {
        return RestResult.genFailResult("开发环境ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //        if (StringUtils.isBlank(core)) {
    //            return RestResult.genFailResult("核心数不能为空");
    //        }
    //        if (StringUtils.isBlank(memorySize)) {
    //            return RestResult.genFailResult("内存大小不能为空");
    //        }
    //        if (StringUtils.isBlank(gpuSize)) {
    //            return RestResult.genFailResult("GPU大小不能为空");
    //        }
    try {
        //根据项目ID查询该项目当前资源占用情况
        GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
        if (gdaiProject == null) {
            return RestResult.genFailResult("该项目不存在");
        }
        GdaiImage gdaiImage = gdaiImageMapper.selectById(imageId);
        if (gdaiImage == null) {
            return RestResult.genFailResult("该配置模版不存在");
        }
        gdaiDevModel.setYmlContent(gdaiImage.getPubYmlContent());
        String context = gdaiDevModel.getContext();
        JSONObject contextObj = new JSONObject();
        if (StringUtils.isNotEmpty(context)) {
            contextObj = JSON.parseObject(context);
        }
        if (contextObj != null && !contextObj.isEmpty()) {
            if (gdaiDevModelVo.getCore() == null) {
                core = contextObj.getString("core");
            }
            if (gdaiDevModelVo.getMemorySize() == null) {
                memorySize = contextObj.getString("memory");
            }
            if (gdaiDevModelVo.getGpuSize() == null) {
                if (contextObj.getJSONObject("gpu") != null) {
                    gpuSize = contextObj.getJSONObject("gpu").getString("gpuSize");
                } else {
                    gpuSize = "0";
                }
            }
        }
        RestResult limitsOfResources = resourceQuotaService.reachLimitsOfResources("", GdaiConstant.NAMESPACE_PREFIX + projectId, Integer.parseInt(core), Integer.parseInt(memorySize.replace("G", "")), //TBD vcuda-core 待添加字段
        Integer.parseInt("0"), Integer.parseInt(gpuSize), // 暂时用不到
        Integer.parseInt("0"));
        if (limitsOfResources != null && limitsOfResources.getSuccess() != 0) {
            return RestResult.genFailResult(limitsOfResources.getMessage());
        }
        GdaiImage curGdaiImage = gdaiImageMapper.selectById(gdaiDevModel.getImageId());
        if (curGdaiImage == null) {
            return RestResult.genFailResult("开发环境信息不存在");
        }
        //获取模板
        gdaiDevModel.setYmlContent(curGdaiImage.getPubYmlContent());
        if (gdaiDevModel.getAlgorithmId() != null) {
            GdaiAlgorithmManage algorithmManage = gdaiAlgorithmManageMapper.selectById(gdaiDevModel.getAlgorithmId());
            if (algorithmManage == null) {
                return RestResult.genFailResult("算法管理信息不存在");
            }
            if (algorithmManage.getDevId() != 0) {
                return RestResult.genFailResult("算法己绑定");
            }
            gdaiDevModel.setJupyterWkdir(algorithmManage.getAlgorithmSavePath());
        } else {
            GdaiAlgorithmManage algorithmManage = GdaiAlgorithmManage.builder().algorithmName(gdaiDevModel.getDevName()).algorithmDesc(gdaiDevModel.getDevName()).imageId(imageId).shareFlag(shareFlag).projectId(projectId).creatorId(userId).build();
            GdaiAlgorithmManage gdaiAlgorithmManage = gdaiAlgorithmManageService.addAlgorithmManage(algorithmManage);
            String jupyterWkdir = gdaiAlgorithmManage.getAlgorithmSavePath();
            gdaiDevModel.setJupyterWkdir(jupyterWkdir);
            gdaiDevModel.setAlgorithmId(gdaiAlgorithmManage.getAlgorithmId());
        }
        //算力大小默认设置为50%
        gdaiDevModel.setComputingPower("");
        //这里默认使用1张卡
        gdaiDevModel.setCardNumber(number);
        gdaiDevModel.setCore(core);
        //            gdaiDevModel.setMemorySize(memorySize);
        gdaiDevModel.setMemorySize(memorySize.replaceAll("G", "Gi"));
        gdaiDevModel.setGpuSize(gpuSize);
        gdaiDevModel.setProjectId(projectId);
        gdaiDevModel.setStatus("S0C");
        gdaiDevModel.setCreatorId(userId);
        gdaiDevModel.setCreateTime(new Date());
        //解决字段非空约束,默认赋值为空
        gdaiDevModel.setCntrMsg("{}");
        gdaiDevModelMapper.insert(gdaiDevModel);
        //更新开发id
        GdaiAlgorithmManage algorithmManage = gdaiAlgorithmManageMapper.selectById(gdaiDevModel.getAlgorithmId());
        if (algorithmManage == null) {
            return RestResult.genFailResult("算法管理信息不存在");
        }
        algorithmManage.setDevId(gdaiDevModel.getDevId());
        gdaiAlgorithmManageMapper.updateById(algorithmManage);
        //            String jupyterWkdir = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.JUPYTER_WKDIR + "/" + devId;
        //            FileUtil.createDir(jupyterWkdir);
        //            File directory = DirectoryUtils.createDirectory(projectId.toString(), userId.toString(), GdaiConstant.JUPYTER_WKDIR, devId.toString());
        //            if (directory == null) {
        //                return RestResult.genFailResult("算法开发目录创建异常");
        //            }
        //            String jupyterWkdir = directory.getAbsolutePath();
        //            String jupyterWkdir = gdaiAlgorithmManage.getAlgorithmSavePath();
        //            gdaiDevModelMapper.updateById(new GdaiDevModel(devId, jupyterWkdir));
        //            gdaiDevModel.setJupyterWkdir(jupyterWkdir);
        //另起线程创建开发容器
        //设置命名空间，按项目划分 gdai-projectId
        gdaiDevModel.setNamespaceName(GdaiConstant.NAMESPACE_PREFIX + projectId);
        //            uploadThreadPool.execute(new GdaiDevModelServiceImpl.StartCreateContainer(gdaiDevModel,
        //                    gdaiNodeInfoService, gdaiProjectService, this,
        //                    gdaiDevModelMapper, k8sClientOperator));
        gdaiDevModelAsyncTask.startDevModel(gdaiDevModel);
    } catch (Exception e) {
        log.info("新增开发容器异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增开发容器异常:" + e.getMessage());
    }
    return RestResult.genSuccessResult("开始新建开发容器");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.entity.GdaiImage
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.io.File
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private GdaiImageMapper gdaiImageMapper;
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Resource
private GdaiAlgorithmManageService gdaiAlgorithmManageService;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiDevModelAsyncTask gdaiDevModelAsyncTask;
@Resource
private K8sClientOperator k8sClientOperator;
@Autowired
private HttpServletRequest request;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiDevModel gdaiDevModel) throws TrainginCenterException {
    log.info("GdaiDevModelServiceImpl.update params: [{}]", JSON.toJSONString(gdaiDevModel));
    Long devId = gdaiDevModel.getDevId();
    String status = gdaiDevModel.getStatus();
    if (devId == null) {
        return RestResult.genFailResult("开发ID不能为空");
    }
    if (StringUtils.isBlank(status)) {
        return RestResult.genFailResult("状态不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDevModel devModel = checkGdaiDevModel(user, devId, true);
    //        GdaiDevModel devModel = gdaiDevModelMapper.selectById(devId);
    //        if (devModel == null) {
    //            return RestResult.genFailResult("该记录不存在");
    //        }
    GdaiDevModel dev = new GdaiDevModel();
    dev.setDevId(devId);
    dev.setStatus(status);
    dev.setCreateTime(new Date());
    gdaiDevModelMapper.updateById(dev);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiDevModel gdaiDevModel) throws TrainginCenterException {
    log.info("GdaiDevModelServiceImpl.updateShareFlag params: [{}]", JSON.toJSONString(gdaiDevModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long devId = gdaiDevModel.getDevId();
    String shareFlag = gdaiDevModel.getShareFlag();
    if (devId == null) {
        return RestResult.genFailResult("开发ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    GdaiDevModel devModel = checkGdaiDevModel(user, devId, false);
    //        GdaiDevModel devModel = gdaiDevModelMapper.selectById(devId);
    //        if (devModel == null) {
    //            return RestResult.genFailResult("该记录不存在");
    //        }
    //        //修改之前判断当前修改人是否和创建人一致（该条记录的创建者才有修改权限）
    //        Long creatorId = devModel.getCreatorId();
    //        if (!creatorId.equals(userId)) {
    //            return RestResult.genFailResult("非创建者不能修改该状态");
    //        }
    GdaiDevModel dev = new GdaiDevModel();
    dev.setDevId(devId);
    dev.setShareFlag(shareFlag);
    dev.setModifyTime(new Date());
    gdaiDevModelMapper.updateById(dev);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为queryDevModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryDevModel(GdaiDevModelVo gdaiDevModelVo) {
    log.info("GdaiDevModelServiceImpl.queryDevModel params: [{}]", JSON.toJSONString(gdaiDevModelVo));
    Long projectId = gdaiDevModelVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String devName = gdaiDevModelVo.getDevName();
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员创建的任务
        UiPage<GdaiDevModelVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiDevModelVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiDevModel> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId);
        // 如果devName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(devName)) {
            wrapper.like("dev_name", devName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiDevModel> gdaiDevModelPage = gdaiDevModelService.selectPage(new Page<>(gdaiDevModelVo.getPageNumber(), gdaiDevModelVo.getPageCount()), wrapper);
        if (gdaiDevModelPage != null && gdaiDevModelPage.getRecords().size() > 0) {
            List<GdaiDevModel> records = gdaiDevModelPage.getRecords();
            for (GdaiDevModel gdaiDevModel : records) {
                //根据用户ID获取用户名称
                gdaiDevModelVo = new GdaiDevModelVo();
                BeanUtils.copyProperties(gdaiDevModel, gdaiDevModelVo);
                Long creatorId = gdaiDevModel.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiDevModelVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiDevModelVo);
            }
            uiPage.setTotal(gdaiDevModelPage.getTotal());
            uiPage.setPageSize(gdaiDevModelPage.getSize());
            uiPage.setPages(gdaiDevModelPage.getPages());
            uiPage.setPageNum(gdaiDevModelPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    } else {
        UiPage<GdaiDevModelVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiDevModelVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiDevModel> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId).andNew().eq("share_flag", "1").or().eq("creator_id", userId);
        // 如果devName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(devName)) {
            wrapper.like("dev_name", devName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiDevModel> gdaiDevModelPage = gdaiDevModelService.selectPage(new Page<>(gdaiDevModelVo.getPageNumber(), gdaiDevModelVo.getPageCount()), wrapper);
        if (gdaiDevModelPage != null && gdaiDevModelPage.getRecords().size() > 0) {
            List<GdaiDevModel> records = gdaiDevModelPage.getRecords();
            for (GdaiDevModel gdaiDevModel : records) {
                gdaiDevModelVo = new GdaiDevModelVo();
                BeanUtils.copyProperties(gdaiDevModel, gdaiDevModelVo);
                Long creatorId = gdaiDevModel.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiDevModelVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiDevModelVo);
            }
            uiPage.setTotal(gdaiDevModelPage.getTotal());
            uiPage.setPageSize(gdaiDevModelPage.getSize());
            uiPage.setPages(gdaiDevModelPage.getPages());
            uiPage.setPageNum(gdaiDevModelPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiDevModelVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDevModelService gdaiDevModelService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为queryDevModelById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryDevModelById(GdaiDevModel gdaiDevModel) throws TrainginCenterException {
    log.info("GdaiDevModelServiceImpl.queryDevModelById params: [{}]", JSON.toJSONString(gdaiDevModel));
    Long devId = gdaiDevModel.getDevId();
    if (devId == null) {
        return RestResult.genFailResult("开发ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDevModel devModel = checkGdaiDevModel(user, devId, true);
    return RestResult.genSuccessResult(devModel);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
org.springframework.stereotype.Service
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为queryDevModelList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<ApplicationVo> queryDevModelList(Long projectId) {
    try {
        return gdaiDevModelMapper.queryDevModelList(projectId);
    } catch (Exception e) {
        log.error(e.getMessage());
        return null;
    }
}
### 类导入的包
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiDevModel gdaiDevModel) {
    log.info("GdaiDevModelServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiDevModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long devId = gdaiDevModel.getDevId();
    Long projectId = gdaiDevModel.getProjectId();
    if (devId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
    if (gdaiProject == null) {
        return RestResult.genFailResult("该项目不存在");
    }
    try {
        //根据ID查询该部署记录是否存在
        //修复水平越权问题
        GdaiDevModel devModel = checkGdaiDevModel(user, devId, false);
        String serviceName = devModel.getServiceName();
        String namespaceName = devModel.getNamespaceName();
        String deploymentName = devModel.getDeploymentName();
        String podLabelSelector = devModel.getPodLabelSelector();
        //删除之前查询该pod节点
        ApiClient clients = k8sInit2.getConnection();
        CoreV1Api apiInstances = new CoreV1Api(clients);
        V1PodList v1PodList = apiInstances.listNamespacedPod(StringUtils.isBlank(devModel.getNamespaceName()) ? "" : devModel.getNamespaceName(), null, null, null, null, podLabelSelector, null, null, null, null, null);
        //删除部署的服务
        if (StringUtils.isNotBlank(serviceName) && StringUtils.isNotBlank(namespaceName)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            V1ServiceList v1ServiceList = apiInstance.listNamespacedService(namespaceName, null, null, null, null, null, null, null, null, null, null);
            List<V1Service> items = v1ServiceList.getItems();
            for (V1Service v1Service : items) {
                String name = v1Service.getMetadata().getName();
                if (serviceName.equals(name)) {
                    apiInstance.deleteNamespacedService(serviceName, namespaceName, null, null, 0, null, "", new V1DeleteOptions());
                    break;
                }
            }
        }
        //删除deployment
        if (StringUtils.isNotBlank(deploymentName) && StringUtils.isNotBlank(namespaceName)) {
            ApiClient client = k8sInit2.getConnection();
            AppsV1Api api = new AppsV1Api(client);
            V1DeploymentList v1DeploymentList = api.listNamespacedDeployment(namespaceName, null, null, null, null, null, null, null, null, null, null);
            List<V1Deployment> items = v1DeploymentList.getItems();
            for (V1Deployment v1Deployment : items) {
                String name = v1Deployment.getMetadata().getName();
                if (deploymentName.equals(name)) {
                    api.deleteNamespacedDeployment(deploymentName, namespaceName, null, null, 0, null, "", new V1DeleteOptions());
                    break;
                }
            }
        }
        //删除对应算法代码   在算法管理删除
        //            String jupyterWkdir = devModel.getJupyterWkdir();
        //            if (StringUtils.isNotBlank(jupyterWkdir)) {
        //                File file = FileUtils.getFile(jupyterWkdir);
        //                if (file.exists()) {
        //                    FileUtil.deleteFile(file);
        //                }
        //            }
        //            //服务删除之后如果原服务状态为Running则恢复占用资源，
        //            if (StringUtils.isNotBlank(phase) && "Running".equals(phase)) {
        //                //释放配额
        //                gdaiProjectService.releaseProject(projectId, "dev", devModel.getCore(), devModel.getMemorySize(), devModel.getGpuSize());
        //                //释放资源
        //                gdaiNodeInfoService.releaseNode(nodeIp, "dev", devModel.getCore(), devModel.getMemorySize(), devModel.getGpuSize());
        //            }
        Long algorithmId = devModel.getAlgorithmId();
        //将算法管理表中devId置为0
        log.info("algorithmId:[{}]", algorithmId);
        gdaiAlgorithmManageMapper.updateByAlgorithmId(algorithmId);
        //删除创建的开发记录
        gdaiDevModelMapper.deleteById(devId);
        //            //tbd 更新资源占用信息
        //            gdaiProjectService.updateProjectResource(projectId);
        return RestResult.genSuccessResult("删除成功");
    } catch (Exception e) {
        log.info("删除开发容器异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return RestResult.genFailResult("删除开发容器异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1DeploymentList
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
io.kubernetes.client.openapi.models.V1Service
io.kubernetes.client.openapi.models.V1ServiceList
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.io.File
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为startNotebook的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult startNotebook(GdaiDevModel gdaiDevModel) throws TrainginCenterException {
    log.info("GdaiDevModelServiceImpl.startNotebook params: [{}]", JSON.toJSONString(gdaiDevModel));
    Long devId = gdaiDevModel.getDevId();
    Long projectId = gdaiDevModel.getProjectId();
    if (devId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    gdaiDevModel = checkGdaiDevModel(user, devId, true);
    try {
        deploymentService.scaleDeployment("", gdaiDevModel.getNamespaceName(), gdaiDevModel.getDeploymentName(), 1);
        gdaiDevModelMapper.updateById(new GdaiDevModel(devId, "S0C", new Date()));
        return RestResult.genSuccessResult("启动成功");
    } catch (Exception e) {
        log.info("启动异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    //        ApiClient client = k8sInit2.getConnection();
    //        AppsV1Api appsInstance = new AppsV1Api(client);
    //        CoreV1Api apiInstance = new CoreV1Api(client);
    //        // 重启容器， 把其副本修改为1， 更新副本的json串
    //        String jsonPatchStr = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\", \"value\": " + "1" + " }]";
    //        V1Patch body = new V1Patch(jsonPatchStr);
    //        try {
    ////            //预占资源
    ////            RestResult result = gdaiProjectService.applyProject(gdaiDevModel.getProjectId(), "dev", gdaiDevModel.getCore(), gdaiDevModel.getMemorySize(), gdaiDevModel.getGpuSize());
    ////            if (!Objects.equals(result.getCode(), "200")) {
    ////                throw new Exception(result.getMessage());
    ////            }
    //
    //            appsInstance.patchNamespacedDeployment(gdaiDevModel.getDeploymentName(), gdaiDevModel.getNamespaceName(), body, null, null, null, null);
    //            //sleep是给容器启动预留一定时间
    //            Thread.sleep(10 * 1000);
    //            //启动成功之后更新pod名称
    //            V1PodList v1PodList = apiInstance.listNamespacedPod(gdaiDevModel.getNamespaceName(), null, null, null, null, null, null, null, null, null, null);
    //            String nodeIp = "";
    //            if (v1PodList != null && v1PodList.getItems().size() > 0) {
    //                String phase = null;
    //                List<V1Pod> items = v1PodList.getItems();
    //                String podName = "";
    //                for (V1Pod v1Pod : items) {
    //                    podName = v1Pod.getMetadata().getName();
    //                    if (podName.contains(gdaiDevModel.getDeploymentName())) {
    //                        phase = v1Pod.getStatus().getPhase();
    //                        //查询该容器在那个节点上
    //                        nodeIp = v1Pod.getSpec().getNodeName();
    //                        break;
    //                    }
    //                }
    //                if (StringUtils.isNotBlank(podName) && "Running".equals(phase)) {
    ////                    gdaiDevModelMapper.updateById(new GdaiDevModel(devId, podName, "S0R", new Date()));
    //                    gdaiDevModel.setPodName(podName);
    //                    gdaiDevModel.setStatus("S0R");
    //                    gdaiDevModel.setModifyTime(new Date());
    //                    //4 获取Jupyter路径
    //                    getJupyterUrlV2(gdaiDevModel, gdaiDevModel.getNodePort());
    //                    gdaiDevModelMapper.updateById(gdaiDevModel);
    //
    ////                    //扣减资源
    ////                    gdaiNodeInfoService.applyNode(nodeIp, "dev", gdaiDevModel.getCore(), gdaiDevModel.getMemorySize(), gdaiDevModel.getGpuSize());
    ////                    //service创建成功，则扣除所占资源
    ////                    //tbd 更新资源占用信息
    ////                    gdaiProjectService.updateProjectResource(projectId);
    //
    //                    return RestResult.genSuccessResult("启动成功");
    //                }
    //            }
    //        } catch (Exception e) {
    //            log.info("启动异常", e);
    //            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    //        }
    gdaiDevModelMapper.updateById(new GdaiDevModel(devId, "S0T", new Date()));
    return RestResult.genFailResult("启动异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private K8sInit2 k8sInit2;
@Resource
private DeploymentService deploymentService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为stopNotebook的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult stopNotebook(GdaiDevModel gdaiDevModel) throws TrainginCenterException {
    log.info("GdaiDevModelServiceImpl.stopNotebook params: [{}]", JSON.toJSONString(gdaiDevModel));
    Long devId = gdaiDevModel.getDevId();
    Long projectId = gdaiDevModel.getProjectId();
    if (devId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    gdaiDevModel = checkGdaiDevModel(user, devId, true);
    try {
        deploymentService.scaleDeployment("", gdaiDevModel.getNamespaceName(), gdaiDevModel.getDeploymentName(), 0);
        gdaiDevModel.setJupyterUrl("");
        gdaiDevModel.setStatus("S0TC");
        gdaiDevModel.setModifyTime(new Date());
        gdaiDevModelMapper.updateById(gdaiDevModel);
        return RestResult.genSuccessResult("启动成功");
    } catch (Exception e) {
        log.info("启动异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    //
    //
    //        ApiClient client = k8sInit2.getConnection();
    //        AppsV1Api appsInstance = new AppsV1Api(client);
    //        CoreV1Api apiInstance = new CoreV1Api(client);
    //        // 停止容器， 把其副本修改为0， 更新副本的json串
    //        String jsonPatchStr = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\", \"value\": " + "0" + " }]";
    //        V1Patch body = new V1Patch(jsonPatchStr);
    //        try {
    //            //删除之前查询该pod节点
    //            V1PodList v1PodList = apiInstance.listNamespacedPod(gdaiDevModel.getNamespaceName(), null, null, null, null, gdaiDevModel.getPodLabelSelector(), null, null, null, null, null);
    //            String nodeIp = "";
    //            if (v1PodList != null && v1PodList.getItems().size() > 0) {
    //                List<V1Pod> items = v1PodList.getItems();
    //                nodeIp = items.get(0).getSpec().getNodeName();
    //            }
    //            V1Deployment v1Deployment = appsInstance.patchNamespacedDeployment(gdaiDevModel.getDeploymentName(), gdaiDevModel.getNamespaceName(), body, null, null, null, null);
    //            //sleep是给容器停止预留一定时间
    //            Thread.sleep(20 * 1000);
    //            gdaiDevModelMapper.updateById(new GdaiDevModel(devId, "S0T", new Date()));
    //            //根据项目ID查询该项目当前资源占用情况
    //            GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
    //            if (gdaiProject == null) {
    //                return RestResult.genFailResult("该项目不存在");
    //            }
    //            //训练任务结束释放所占用资源
    //
    ////            //释放配额
    ////            gdaiProjectService.releaseProject(projectId, "dev", gdaiDevModel.getCore(), gdaiDevModel.getMemorySize(), gdaiDevModel.getGpuSize());
    ////            //释放资源
    ////            gdaiNodeInfoService.releaseNode(nodeIp, "dev", gdaiDevModel.getCore(), gdaiDevModel.getMemorySize(), gdaiDevModel.getGpuSize());
    ////            //更新资源占用信息
    ////            gdaiProjectService.updateProjectResource(projectId);
    //            return RestResult.genSuccessResult("停止成功");
    //        } catch (Exception e) {
    //            log.info("停止异常", e);
    //            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    //        }
    gdaiDevModelMapper.updateById(new GdaiDevModel(devId, "S0R", new Date()));
    return RestResult.genFailResult("停止异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private DeploymentService deploymentService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为saveCode的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult saveCode(GdaiDevModelVo gdaiDevModelVo) throws TrainginCenterException {
    log.info("GdaiDevModelServiceImpl.saveCode params: [{}]", JSON.toJSONString(gdaiDevModelVo));
    GdaiDevModel gdaiDevModel = new GdaiDevModel();
    BeanUtils.copyProperties(gdaiDevModelVo, gdaiDevModel);
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    String devName = gdaiDevModelVo.getDevName();
    Long projectId = gdaiDevModelVo.getProjectId();
    Long imageId = gdaiDevModelVo.getImageId();
    String jupyterWkdir = gdaiDevModelVo.getJupyterWkdir();
    Long devId = gdaiDevModelVo.getDevId();
    if (StringUtils.isBlank(devName)) {
        return RestResult.genFailResult("名称不能为空");
    }
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (imageId == null) {
        return RestResult.genFailResult("开发环境ID不能为空");
    }
    if (StringUtils.isBlank(jupyterWkdir)) {
        return RestResult.genFailResult("代码保存路径不能为空");
    }
    File file = FileUtils.getFile(jupyterWkdir);
    if (!file.exists()) {
        return RestResult.genFailResult("代码保存路径不存在");
    }
    if (devId == null) {
        return RestResult.genFailResult("模型开发ID不能为空");
    }
    //修复水平越权问题
    checkGdaiDevModel(user, devId, true);
    try {
        //查询同项目下是否存在同名算法包
        GdaiAlgorithmManage algorithmManage = gdaiAlgorithmManageMapper.selectOne(new GdaiAlgorithmManage(devName, projectId, userId));
        if (algorithmManage != null) {
            //将模型开发代码保存在算法管理中
            String algorithmSavePath = algorithmManage.getAlgorithmSavePath();
            if (!jupyterWkdir.equals(algorithmSavePath)) {
                FileUtils.copyDirectory(FileUtils.getFile(jupyterWkdir), FileUtils.getFile(algorithmSavePath));
            }
            return RestResult.genSuccessResult("保存成功");
        }
        //新增算法管理记录到表中
        Date curDate = new Date();
        GdaiAlgorithmManage gdaiAlgorithmManage = new GdaiAlgorithmManage();
        gdaiAlgorithmManage.setAlgorithmName(devName);
        gdaiAlgorithmManage.setProjectId(projectId);
        gdaiAlgorithmManage.setImageId(imageId);
        gdaiAlgorithmManage.setDevId(devId);
        gdaiAlgorithmManage.setCreatorId(userId);
        gdaiAlgorithmManage.setCreateTime(curDate);
        gdaiAlgorithmManage.setModifyTime(curDate);
        gdaiAlgorithmManageMapper.insert(gdaiAlgorithmManage);
        Long algorithmId = gdaiAlgorithmManage.getAlgorithmId();
        //拼装算法包保存路径
        //            String algorithmSavePath = cephUploadPath + "/algorithm/" + projectId + "/" + algorithmId + breakpointPath;
        //            String rootPath = cephUploadPath + "/algorithm/" + projectId + "/" + algorithmId;
        String algorithmSavePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.ALGORITHM + "/" + algorithmId + GdaiConstant.BREAK_POINT_PATH;
        String rootPath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.ALGORITHM + "/" + algorithmId;
        gdaiAlgorithmManageMapper.updateById(new GdaiAlgorithmManage(algorithmId, algorithmSavePath, rootPath));
        //将模型开发代码保存在算法管理中(如果源路径与目标路径相同则无需重复拷贝)
        if (!jupyterWkdir.equals(algorithmSavePath)) {
            FileUtils.copyDirectory(FileUtils.getFile(jupyterWkdir), FileUtils.getFile(algorithmSavePath));
        }
        //更新模型开发表中algorithmId
        gdaiDevModelMapper.updateById(new GdaiDevModel(devId, algorithmId));
    } catch (Exception e) {
        log.info("代码保存异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("保存异常");
    }
    return RestResult.genSuccessResult("保存成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmManage
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiAlgorithmManageMapper gdaiAlgorithmManageMapper;
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
@Value("${cephUpload.breakpointPath}")
private String breakpointPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为getJupyterUrl的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getJupyterUrl(GdaiDevModel gdaiDevModel) throws TrainginCenterException {
    log.info("GdaiDevModelServiceImpl.getJupyterUrl params: [{}]", JSON.toJSONString(gdaiDevModel));
    Long devId = gdaiDevModel.getDevId();
    if (devId == null) {
        return RestResult.genFailResult("开发ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiDevModel devModel = checkGdaiDevModel(user, devId, true);
    try {
        if (StringUtils.isEmpty(devModel.getJupyterUrl())) {
            String jupyterUrl = getJupyterUrlV3(devModel);
            if (StringUtils.isEmpty(jupyterUrl)) {
                throw new TrainginCenterException("启动中，请稍后再试！");
            }
            devModel.setJupyterUrl(jupyterUrl);
        }
        devModel.setModifyTime(new Date());
        gdaiDevModelMapper.updateById(devModel);
        return RestResult.genSuccessResult(devModel.getJupyterUrl());
    } catch (Exception e) {
        return RestResult.genFailResult("Notebook启动中，请稍后再试！");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.service.GdaiDevModelService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为createContainer的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 向k8s创建开发容器
     *
     * @param gdaiDevModel
     * @return
     */
public GdaiDevModel createContainer(GdaiDevModel gdaiDevModel, GdaiDevModelMapper gdaiDevModelMapper, GdaiNodeInfoService gdaiNodeInfoService, K8sClientOperator k8sClientOperator) throws Exception {
    String ymlContent = "";
    try {
        //TBD 存量的项目创建namespace
        k8sClientOperator.createNamespaceIfNotExist(gdaiDevModel.getNamespaceName());
        // 1、获取模板
        String ymlContentInImage = gdaiDevModel.getYmlContent();
        // log.info("testonlyhere ymlContent=" + ymlContent) ;
        // 和算法提供的模板匹配，目前一个yaml模板包含第一个是deployment， 第二个是service的定义
        int indexSplitChars = ymlContentInImage.indexOf("---");
        //替换模型
        log.info("GdaiDevModel createContainer GdaiDevModel 替换模型：\n" + JSON.toJSONString(gdaiDevModel));
        //2.1 deployment模板处理
        String ymlContent4Deployment = ymlContentInImage.substring(0, indexSplitChars);
        log.info("GdaiDevModel createContainer Deployment 替换前模板：\n" + ymlContent4Deployment);
        //替换模板参数
        V1Deployment yamlDeployment = YamlUtil.loadObject(ymlContent4Deployment, gdaiDevModel, V1Deployment.class);
        //替换后的yaml
        String yamlDeploymentStr = io.kubernetes.client.util.Yaml.dump(yamlDeployment);
        log.info("GdaiDevModel createContainer Deployment 替换后模板:\n " + yamlDeploymentStr);
        //保存yaml
        ymlContent = yamlDeploymentStr;
        //2.2 service模板处理
        String ymlContent4Service = ymlContentInImage.substring(indexSplitChars + 3);
        log.info("GdaiDevModel createContainer Service 替换前模板：\n" + ymlContent4Service);
        //替换模板参数
        V1Service yamlService = YamlUtil.loadObject(ymlContent4Service, gdaiDevModel, V1Service.class);
        //替换后的yaml
        String yamlServiceStr = io.kubernetes.client.util.Yaml.dump(yamlService);
        log.info("GdaiDevModel createContainer Service 替换后模板:\n " + yamlServiceStr);
        //保存yaml
        ymlContent = (yamlDeploymentStr + "\n" + "---" + "\n" + yamlServiceStr);
        //3.1 创建deployment
        gdaiDevModel = createDeployment(gdaiDevModel, yamlDeployment, k8sClientOperator);
        //3.2 创建Service
        // 创建完deployment,预留时间给k8s创建 service, 若300秒没创建完， 简单设置为失败
        //            if (!k8sClientOperator.checkPodStatus(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector(), 300)) {
        //                log.info("waiting create pod timeout");
        //                throw new Exception("创建开发Pod容器超时");
        //            }
        gdaiDevModel = createService(gdaiDevModel, yamlService, k8sClientOperator);
        //TBD
        // 创建完deployment,预留时间给k8s创建 pod, 若120秒没创建完， 简单设置为失败
        //            long waitTime = 0;
        //            while (true) {
        //                Thread.sleep(10 * 1000);
        //                waitTime = waitTime + 10;
        //                buildCntrMsg("creating", gdaiDevModel, k8sClientOperator);
        //                gdaiDevModelMapper.updateById(gdaiDevModel);
        //                if (k8sClientOperator.checkPodCreatedV2(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector())) {
        //                    //创建deployment
        //                    gdaiDevModel = createService(gdaiDevModel, yamlService, k8sClientOperator);
        //                    break;
        //                } else {
        //                    if (waitTime > 100) {
        //                        log.info("waiting create pod timeout");
        //                        throw new Exception("等待创建开发POD容器超时");
        //                    } else {
        //                        continue;
        //                    }
        //                }
        //            }
        //TBD 等待pod启动，更新状态应该放到task里面去
        PodBo podBo = podService.waitForPodToRuning("", gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector(), 300);
        gdaiDevModel.setPodName(podBo.getName());
        gdaiDevModel.setYmlContent(ymlContent);
        gdaiDevModel.setStatus("S0R");
        gdaiDevModel.setModifyTime(new Date());
        buildCntrMsg("success", gdaiDevModel, k8sClientOperator);
        //4 获取Jupyter路径
        //getJupyterUrlV2(gdaiDevModel, gdaiDevModel.getNodePort());
        //            //5 扣减节点资源
        //            applyResource(gdaiDevModel, gdaiNodeInfoService, k8sClientOperator);
        //            //tbd 更新资源占用信息
        //            gdaiProjectService.updateProjectResource(gdaiDevModel.getProjectId());
        return gdaiDevModel;
    } catch (Exception ex) {
        log.error("create k8s deployment exception:", ex);
        gdaiDevModel.setYmlContent(ymlContent);
        gdaiDevModel.setStatus("S0E");
        String cntrMsg = ex.getMessage();
        if (ex.getMessage() != null && ex.getMessage().length() > 200) {
            cntrMsg = ex.getMessage().substring(0, 200);
        }
        buildCntrMsg(cntrMsg, gdaiDevModel, k8sClientOperator);
        //            gdaiDevModel.setCntrMsg(cntrMsg);
        gdaiDevModel.setModifyTime(new Date());
        //创建service异常，删除已创建的deploy
        String deploymentName = gdaiDevModel.getDeploymentName();
        String namespaceName = gdaiDevModel.getNamespaceName();
        if (StringUtils.isNotBlank(deploymentName) && StringUtils.isNotBlank(namespaceName)) {
            //                // 释放节点资源
            //                releaseResource(gdaiDevModel, gdaiNodeInfoService, k8sClientOperator);
            AppsV1Api api = new AppsV1Api();
            try {
                api.deleteNamespacedDeployment(deploymentName, namespaceName, null, null, 0, null, "", new V1DeleteOptions());
            } catch (ApiException e) {
                log.info("删除pod异常", e);
            }
        }
        //            //tbd 更新资源占用信息
        //            gdaiProjectService.updateProjectResource(gdaiDevModel.getProjectId());
        throw new Exception(ex.getMessage());
        //            return gdaiDevModel;gdaiDevModel
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1Service
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private PodService podService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为buildYmlContent的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildYmlContent(GdaiDevModel gdaiDevModel) throws Exception {
    try {
        //添加一些容器的初始参数到context中
        gdaiDevModel.buildContext();
        log.info("buildYmlContent GdaiDevModel context：\n" + gdaiDevModel.getContext());
        String ymlContent = YamlUtil.loadYaml(gdaiDevModel.getYmlContent(), gdaiDevModel.getContext());
        gdaiDevModel.setYmlContent(ymlContent);
        log.info("buildYmlContent GdaiDevModel 替换后模板:\n " + ymlContent);
    } catch (Exception ex) {
        log.error("create k8s deployment exception:", ex);
        throw new Exception(ex);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.util.YamlUtil
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为createDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void createDeployment(GdaiDevModel gdaiDevModel) throws Exception {
    try {
        String yamlContent = gdaiDevModel.getYmlContent();
        DeploymentBo deploymentBo = deploymentService.createDeployment("", gdaiDevModel.getNamespaceName(), yamlContent);
    } catch (Exception e) {
        throw e;
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.DeploymentBo
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private DeploymentService deploymentService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为createService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void createService(GdaiDevModel gdaiDevModel) throws Exception {
    try {
        String yamlContent = gdaiDevModel.getYmlContent();
        ServiceBo serviceBo = serviceService.createService("", gdaiDevModel.getNamespaceName(), yamlContent);
        gdaiDevModel.setNodePort(serviceBo.getPorts().get(0).getNodePort());
    } catch (Exception e) {
        throw e;
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.ServiceBo
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private ServiceService serviceService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为createContainer的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 向k8s创建开发容器
     *
     * @param gdaiDevModel
     * @return
     */
public GdaiDevModel createContainer(GdaiDevModel gdaiDevModel) throws Exception {
    String ymlContent = "";
    try {
        //TBD 存量的项目创建namespace
        k8sClientOperator.createNamespaceIfNotExist(gdaiDevModel.getNamespaceName());
        // 1、获取模板
        String ymlContentInImage = gdaiDevModel.getYmlContent();
        // log.info("testonlyhere ymlContent=" + ymlContent) ;
        // 和算法提供的模板匹配，目前一个yaml模板包含第一个是deployment， 第二个是service的定义
        int indexSplitChars = ymlContentInImage.indexOf("---");
        //替换模型
        log.info("GdaiDevModel createContainer GdaiDevModel 替换模型：\n" + JSON.toJSONString(gdaiDevModel));
        //2.1 deployment模板处理
        String ymlContent4Deployment = ymlContentInImage.substring(0, indexSplitChars);
        log.info("GdaiDevModel createContainer Deployment 替换前模板：\n" + ymlContent4Deployment);
        //替换模板参数
        V1Deployment yamlDeployment = YamlUtil.loadObject(ymlContent4Deployment, gdaiDevModel, V1Deployment.class);
        //替换后的yaml
        String yamlDeploymentStr = io.kubernetes.client.util.Yaml.dump(yamlDeployment);
        log.info("GdaiDevModel createContainer Deployment 替换后模板:\n " + yamlDeploymentStr);
        //保存yaml
        ymlContent = yamlDeploymentStr;
        //2.2 service模板处理
        String ymlContent4Service = ymlContentInImage.substring(indexSplitChars + 3);
        log.info("GdaiDevModel createContainer Service 替换前模板：\n" + ymlContent4Service);
        //替换模板参数
        V1Service yamlService = YamlUtil.loadObject(ymlContent4Service, gdaiDevModel, V1Service.class);
        //替换后的yaml
        String yamlServiceStr = io.kubernetes.client.util.Yaml.dump(yamlService);
        log.info("GdaiDevModel createContainer Service 替换后模板:\n " + yamlServiceStr);
        //保存yaml
        ymlContent = (yamlDeploymentStr + "\n" + "---" + "\n" + yamlServiceStr);
        log.info("创建deploy:{}", gdaiDevModel.getDevId());
        Thread.sleep(1 * 10 * 1000);
        //            gdaiDevModelMapper.insert(gdaiDevModel);
        log.info("创建deploy:{}成功 ", gdaiDevModel.getDevId());
        //3.1 创建deployment
        gdaiDevModel = createDeployment(gdaiDevModel, yamlDeployment, k8sClientOperator);
        //3.2 创建Service
        // 创建完deployment,预留时间给k8s创建 service, 若300秒没创建完， 简单设置为失败
        //            if (!k8sClientOperator.checkPodStatus(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector(), 300)) {
        //                log.info("waiting create pod timeout");
        //                throw new Exception("创建开发Pod容器超时");
        //            }
        gdaiDevModel = createService(gdaiDevModel, yamlService, k8sClientOperator);
        //TBD
        // 创建完deployment,预留时间给k8s创建 pod, 若120秒没创建完， 简单设置为失败
        //            long waitTime = 0;
        //            while (true) {
        //                Thread.sleep(10 * 1000);
        //                waitTime = waitTime + 10;
        //                buildCntrMsg("creating", gdaiDevModel, k8sClientOperator);
        //                gdaiDevModelMapper.updateById(gdaiDevModel);
        //                if (k8sClientOperator.checkPodCreatedV2(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector())) {
        //                    //创建deployment
        //                    gdaiDevModel = createService(gdaiDevModel, yamlService, k8sClientOperator);
        //                    break;
        //                } else {
        //                    if (waitTime > 100) {
        //                        log.info("waiting create pod timeout");
        //                        throw new Exception("等待创建开发POD容器超时");
        //                    } else {
        //                        continue;
        //                    }
        //                }
        //            }
        //TBD 等待pod启动，更新状态应该放到task里面去
        PodBo podBo = podService.waitForPodToRuning("", gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector(), 300);
        gdaiDevModel.setPodName(podBo.getName());
        gdaiDevModel.setYmlContent(ymlContent);
        gdaiDevModel.setStatus("S0R");
        gdaiDevModel.setModifyTime(new Date());
        buildCntrMsg("success", gdaiDevModel, k8sClientOperator);
        //4 获取Jupyter路径
        //getJupyterUrlV2(gdaiDevModel, gdaiDevModel.getNodePort());
        //            //5 扣减节点资源
        //            applyResource(gdaiDevModel, gdaiNodeInfoService, k8sClientOperator);
        //            //tbd 更新资源占用信息
        //            gdaiProjectService.updateProjectResource(gdaiDevModel.getProjectId());
        return gdaiDevModel;
    } catch (Exception ex) {
        log.error("create k8s deployment exception:", ex);
        gdaiDevModel.setYmlContent(ymlContent);
        gdaiDevModel.setStatus("S0E");
        String cntrMsg = ex.getMessage();
        if (ex.getMessage() != null && ex.getMessage().length() > 200) {
            cntrMsg = ex.getMessage().substring(0, 200);
        }
        buildCntrMsg(cntrMsg, gdaiDevModel, k8sClientOperator);
        //            gdaiDevModel.setCntrMsg(cntrMsg);
        gdaiDevModel.setModifyTime(new Date());
        //创建service异常，删除已创建的deploy
        String deploymentName = gdaiDevModel.getDeploymentName();
        String namespaceName = gdaiDevModel.getNamespaceName();
        if (StringUtils.isNotBlank(deploymentName) && StringUtils.isNotBlank(namespaceName)) {
            //                // 释放节点资源
            //                releaseResource(gdaiDevModel, gdaiNodeInfoService, k8sClientOperator);
            AppsV1Api api = new AppsV1Api();
            try {
                api.deleteNamespacedDeployment(deploymentName, namespaceName, null, null, 0, null, "", new V1DeleteOptions());
            } catch (ApiException e) {
                log.info("删除pod异常", e);
            }
        }
        //            //tbd 更新资源占用信息
        //            gdaiProjectService.updateProjectResource(gdaiDevModel.getProjectId());
        throw new Exception(ex.getMessage());
        //            return gdaiDevModel;gdaiDevModel
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1Service
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private PodService podService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为createDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private GdaiDevModel createDeployment(GdaiDevModel gdaiDevModel, V1Deployment deployment, K8sClientOperator k8sClientOperator) throws Exception {
    try {
        V1Deployment createResult = k8sClientOperator.createDeployment(deployment, gdaiDevModel.getNamespaceName());
        //记录k8s动态生成的内容
        gdaiDevModel.setDeploymentName(createResult.getMetadata().getName());
        gdaiDevModel.setPodLabelSelector("app=" + createResult.getSpec().getSelector().getMatchLabels().get("app"));
    } catch (Exception e) {
        throw e;
    }
    return gdaiDevModel;
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Deployment
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为createService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private GdaiDevModel createService(GdaiDevModel gdaiDevModel, V1Service service, K8sClientOperator k8sClientOperator) throws Exception {
    // 现有实现是只适配已知应用yaml的已有属性项，若新应用的yaml有新的属性项，按实际增加相应应的项。
    try {
        V1Service createResult = k8sClientOperator.createService(service, gdaiDevModel.getNamespaceName());
        gdaiDevModel.setNodePort(createResult.getSpec().getPorts().get(0).getNodePort());
        //            gdaiDevModel.setContainerPort(service.getSpec().getPorts().get(0).getTargetPort());
        gdaiDevModel.setServicePort(createResult.getSpec().getPorts().get(0).getPort());
        gdaiDevModel.setServiceName(createResult.getMetadata().getName());
    } catch (Exception e) {
        throw e;
    }
    return gdaiDevModel;
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Service
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为getJupyterUrl的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private Map<String, String> getJupyterUrl(GdaiDevModel gdaiDevModel, Integer curNodePort, K8sInit2 k8sInit2) throws Exception {
    try {
        ApiClient client = k8sInit2.getConnection();
        log.info("testjsonstr client:" + client.getBasePath() + client.getJSON());
        CoreV1Api apiInstance = new CoreV1Api(client);
        V1PodList curV1PodList;
        try {
            curV1PodList = apiInstance.listNamespacedPod(gdaiDevModel.getNamespaceName(), null, null, null, null, gdaiDevModel.getPodLabelSelector(), null, null, null, null, null);
        } catch (Exception e) {
            throw e;
        }
        String podName;
        // 目前约定只有一个pod
        if (curV1PodList == null) {
            return null;
        } else {
            List<V1Pod> v1PodList = curV1PodList.getItems();
            if (v1PodList == null || v1PodList.isEmpty()) {
                return null;
            } else {
                V1Pod curV1Pod = v1PodList.get(0);
                //根据标签查询对应pod获取对应node节点IP地址
                String podIP = curV1Pod.getStatus().getHostIP();
                log.info("testonlyhere curV1Pod:" + curV1Pod);
                podName = curV1Pod.getMetadata().getName();
                String podLogs = apiInstance.readNamespacedPodLog(podName, gdaiDevModel.getNamespaceName(), null, null, null, null, null, null, null, null, null);
                log.info("testonlyhere podLogs:" + podLogs);
                String token = null;
                BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(podLogs.getBytes(Charset.forName("utf8"))), Charset.forName("utf8")));
                String line;
                while ((line = br.readLine()) != null) {
                    if (!line.trim().equals("")) {
                        int index1 = podLogs.indexOf("?token=");
                        if (index1 >= 0) {
                            int indexServerApp = podLogs.indexOf("ServerApp");
                            if (indexServerApp >= 0) {
                                token = (podLogs.substring(index1 + 7, index1 + 7 + 48));
                            }
                        }
                    }
                }
                log.info("testonlyhere token:" + token);
                if (token != null) {
                    String jupyterUrl = "http://" + podIP + ":" + curNodePort + "/lab?token=" + token;
                    Map<String, String> map = new HashMap<>();
                    map.put("podName", podName);
                    map.put("jupyterUrl", jupyterUrl);
                    return map;
                } else {
                    return null;
                }
            }
        }
    } catch (Exception ex) {
        log.error("list k8s deployment exception:", ex);
        throw ex;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
java.io.BufferedReader
java.io.ByteArrayInputStream
java.io.InputStream
java.io.InputStreamReader
java.nio.charset.Charset
java.util.HashMap
java.util.List
java.util.Map
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为getJupyterUrlV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private Map<String, String> getJupyterUrlV2(GdaiDevModel gdaiDevModel, Integer curNodePort) throws Exception {
    try {
        CoreV1Api apiInstance = new CoreV1Api();
        V1PodList curV1PodList;
        try {
            curV1PodList = apiInstance.listNamespacedPod(gdaiDevModel.getNamespaceName(), null, null, null, null, gdaiDevModel.getPodLabelSelector(), null, null, null, null, null);
        } catch (Exception e) {
            throw e;
        }
        String podName;
        // 目前约定只有一个pod
        if (curV1PodList == null) {
            return null;
        } else {
            List<V1Pod> v1PodList = curV1PodList.getItems();
            if (v1PodList == null || v1PodList.isEmpty()) {
                return null;
            } else {
                V1Pod curV1Pod = v1PodList.get(0);
                //根据标签查询对应pod获取对应node节点IP地址
                String podIP = curV1Pod.getStatus().getHostIP();
                podName = curV1Pod.getMetadata().getName();
                String podLogs = apiInstance.readNamespacedPodLog(podName, gdaiDevModel.getNamespaceName(), null, null, null, null, null, null, null, null, null);
                if (StringUtils.isEmpty(podLogs)) {
                    Thread.sleep(30 * 1000L);
                    podLogs = apiInstance.readNamespacedPodLog(podName, gdaiDevModel.getNamespaceName(), null, null, null, null, null, null, null, null, null);
                }
                log.info("testonlyhere podLogs:" + podLogs);
                String token = null;
                BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(podLogs.getBytes(Charset.forName("utf8"))), Charset.forName("utf8")));
                String line;
                while ((line = br.readLine()) != null) {
                    if (!line.trim().equals("")) {
                        int index1 = podLogs.indexOf("?token=");
                        if (index1 >= 0) {
                            int indexServerApp = podLogs.indexOf("ServerApp");
                            if (indexServerApp >= 0) {
                                token = (podLogs.substring(index1 + 7, index1 + 7 + 48));
                            }
                        }
                    }
                }
                log.info("testonlyhere token:" + token);
                if (token != null) {
                    String jupyterUrl = "http://" + podIP + ":" + curNodePort + "/lab?token=" + token;
                    Map<String, String> map = new HashMap<>();
                    map.put("podName", podName);
                    map.put("jupyterUrl", jupyterUrl);
                    gdaiDevModel.setPodName(podName);
                    gdaiDevModel.setJupyterUrl(jupyterUrl);
                    return map;
                } else {
                    return null;
                }
            }
        }
    } catch (Exception ex) {
        log.error("list k8s deployment exception:", ex);
        throw ex;
    }
}
### 类导入的包
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.io.BufferedReader
java.io.ByteArrayInputStream
java.io.InputStream
java.io.InputStreamReader
java.nio.charset.Charset
java.util.HashMap
java.util.List
java.util.Map
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为getJupyterUrlV3的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String getJupyterUrlV3(GdaiDevModel gdaiDevModel) throws Exception {
    try {
        ApiClient client = k8sInit2.getConnection();
        log.info("testjsonstr client:" + client.getBasePath() + client.getJSON());
        CoreV1Api apiInstance = new CoreV1Api(client);
        V1PodList curV1PodList;
        try {
            curV1PodList = apiInstance.listNamespacedPod(gdaiDevModel.getNamespaceName(), null, null, null, null, gdaiDevModel.getPodLabelSelector(), null, null, null, null, null);
        } catch (Exception e) {
            throw e;
        }
        String podName;
        // 目前约定只有一个pod
        if (curV1PodList == null) {
            return null;
        } else {
            List<V1Pod> v1PodList = curV1PodList.getItems();
            if (v1PodList == null || v1PodList.isEmpty()) {
                return null;
            } else {
                V1Pod curV1Pod = v1PodList.get(0);
                //根据标签查询对应pod获取对应node节点IP地址
                String podIP = curV1Pod.getStatus().getHostIP();
                log.info("testonlyhere curV1Pod:" + curV1Pod);
                podName = curV1Pod.getMetadata().getName();
                PodLogs logs = new PodLogs();
                InputStream is = logs.streamNamespacedPodLog(curV1Pod);
                String token = null;
                BufferedReader br = new BufferedReader(new InputStreamReader(is, Charset.forName("utf8")));
                String line;
                while ((line = br.readLine()) != null) {
                    if (!line.trim().equals("")) {
                        int index1 = line.indexOf("?token=");
                        if (index1 >= 0) {
                            int indexServerApp = line.indexOf("ServerApp");
                            if (indexServerApp >= 0) {
                                token = (line.substring(index1 + 7, index1 + 7 + 48));
                                break;
                            }
                        }
                    }
                }
                is.close();
                br.close();
                log.info("testonlyhere token:" + token);
                if (token != null) {
                    String jupyterUrl = "http://" + podIP + ":" + gdaiDevModel.getNodePort() + "/lab?token=" + token;
                    return jupyterUrl;
                } else {
                    return null;
                }
            }
        }
    } catch (Exception ex) {
        log.error("list k8s deployment exception:", ex);
        throw ex;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
io.kubernetes.client.PodLogs
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
java.io.BufferedReader
java.io.InputStream
java.io.InputStreamReader
java.nio.charset.Charset
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为applyResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private void applyResource(GdaiDevModel gdaiDevModel, GdaiNodeInfoService gdaiNodeInfoService, K8sClientOperator k8sClientOperator) throws Exception {
    //再次查询部署容器运行状态
    Long devId = gdaiDevModel.getDevId();
    V1PodList v1PodList = k8sClientOperator.listNamespacedPod(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector());
    if (v1PodList != null && v1PodList.getItems().size() > 0) {
        V1Pod v1Pod = v1PodList.getItems().get(0);
        String podName = v1Pod.getMetadata().getName();
        String phase = v1Pod.getStatus().getPhase();
        if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(phase) && !"Running".equals(phase)) {
            gdaiDevModel.setStatus("S0E");
            gdaiDevModel.setPodName(podName);
            //                gdaiDevModel.setCntrMsg(phase);
        } else {
            //service创建成功，则扣除所占资源
            //查询该容器在那个节点上
            //                String nodeIp = v1Pod.getSpec().getNodeName();
            //                gdaiNodeInfoService.applyNode(nodeIp, "dev", gdaiDevModel.getCore(), gdaiDevModel.getMemorySize(), gdaiDevModel.getGpuSize());
        }
    }
}
### 类导入的包
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为updateCurrentStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void updateCurrentStatus(GdaiDevModel gdaiDevModel) {
    //replicas=0,readyReplicas=0	S0T 停止  （原状态为S0TC 停止中才改状态）
    //replicas>0,readyReplicas=0	S0C 启动中/S0E 运行异常    （查pod表有faild就是异常）
    //replicas>0,readyReplicas>0	S0R 运行中
    String status = "";
    String originStatus = gdaiDevModel.getStatus();
    Integer replicas = gdaiDevModel.getReplicas();
    Integer readyReplicas = gdaiDevModel.getReadyReplicas();
    if (replicas == 0 && readyReplicas == 0) {
        if (!originStatus.equals("S0E")) {
            status = "S0T";
        }
    } else if (replicas > 0 && readyReplicas == 0) {
        status = "S0C";
    } else if (replicas > 0 && readyReplicas > 0) {
        status = "S0R";
    } else if (replicas == 0 && readyReplicas > 0) {
        if (!originStatus.equals("S0E")) {
            status = "S0TC";
        }
    } else {
        log.error("GdaiDevModel deployment status unknow,replicas:" + replicas + ",readyReplicas:" + readyReplicas);
        //status = "S0E";
    }
    if (StringUtils.isNotEmpty(status)) {
        gdaiDevModel.setStatus(status);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为handleResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void handleResource(DeploymentBo deploymentBo, GdaiDevModel gdaiDevModel) throws Exception {
    //处理长时间异常的资源
    Boolean failedFlag = false;
    if ("S0C".equals(gdaiDevModel.getStatus())) {
        List<GdaiPod> pods = gdaiPodService.selectByBizId(gdaiDevModel.getDevId());
        for (GdaiPod pod : pods) {
            if (StringUtils.equals("Failed", pod.getPhase())) {
                failedFlag = true;
                break;
            }
        }
        if (failedFlag) {
            Date creationDate = gdaiDevModel.getCreateTime();
            //计算pod创建到现在时间(分钟)
            Long distanceMin = DateUtil.getDistanceMin(creationDate, new Date());
            //如果pod创建到现在超过了预定义的删除时间，就将其状态设置为S0E
            if (distanceMin > 15) {
                gdaiDevModel.setStatus("S0E");
                //TBD 先不停，方便排查异常
                // 停止容器， 把其副本修改为0，
                //                    deploymentService.scaleDeployment("", gdaiDevModel.getNamespaceName(), gdaiDevModel.getDeploymentName(),0);
                gdaiDevModelMapper.updateForCallback(gdaiDevModel);
                log.info("dev_model podCallback update: {} {}", gdaiDevModel.getDevName(), gdaiDevModel.getStatus());
            }
        }
    }
    if ("S0R".equals(gdaiDevModel.getStatus()) || "S0C".equals(gdaiDevModel.getStatus())) {
        //ModifyTime起过5小时，停止当前容器
        Long modifyTime = gdaiDevModel.getModifyTime().getTime();
        long now = new Date().getTime();
        if ((now - modifyTime) > 1000 * 60 * 60 * 5) {
            deploymentService.scaleDeployment("", gdaiDevModel.getNamespaceName(), gdaiDevModel.getDeploymentName(), 0);
            gdaiDevModel.setJupyterUrl("");
            gdaiDevModel.setStatus("S0TC");
            gdaiDevModel.setModifyTime(new Date());
            gdaiDevModelMapper.updateById(gdaiDevModel);
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.k8s.service.PodService
com.eshore.gdai.trainingcenter.util.DateUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private DeploymentService deploymentService;
@Resource
private GdaiPodService gdaiPodService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为checkJupyterNewToken的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public GdaiDevModel checkJupyterNewToken(GdaiDevModel gdaiDevModel) {
    Integer curNodePort = gdaiDevModel.getNodePort();
    try {
        Map<String, String> map = getJupyterUrl(gdaiDevModel, curNodePort, k8sInit2);
        String jupyterUrl = map.get("jupyterUrl");
        if ((jupyterUrl != null) && (jupyterUrl.trim().length() > 0) && (!jupyterUrl.equalsIgnoreCase(gdaiDevModel.getJupyterUrl()))) {
            log.info("checkJupyterNewToken devId:" + gdaiDevModel.getDevId() + ",old jupyterUrl:", gdaiDevModel.getJupyterUrl());
            log.info("checkJupyterNewToken new jupyterUrl:", jupyterUrl);
            gdaiDevModel.setJupyterUrl(jupyterUrl);
            gdaiDevModel.setModifyTime(new Date());
            this.updateById(gdaiDevModel);
        }
    } catch (Exception ex) {
        log.error("checkJupyterNewToken exception:", ex);
        return gdaiDevModel;
    }
    return gdaiDevModel;
}
### 类导入的包
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为buildCntrMsg的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildCntrMsg(String message, GdaiDevModel gdaiDevModel, K8sClientOperator k8sClientOperator) throws Exception {
    JSONObject object = new JSONObject();
    if (StringUtils.isNotEmpty(gdaiDevModel.getCntrMsg())) {
        object = JSON.parseObject(gdaiDevModel.getCntrMsg());
    }
    object.put("message", message);
    if (StringUtils.isEmpty(gdaiDevModel.getPodName())) {
        V1PodList curV1PodList = k8sClientOperator.listNamespacedPod(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector());
        if (curV1PodList != null && !curV1PodList.getItems().isEmpty()) {
            gdaiDevModel.setPodName(curV1PodList.getItems().get(0).getMetadata().getName());
        }
    }
    if (StringUtils.isNotEmpty(gdaiDevModel.getPodName())) {
        List<Event> events = k8sClientOperator.getEvents(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodName());
        if (events != null) {
            object.put("event", events);
        }
    }
    if (StringUtils.isNotEmpty(gdaiDevModel.getDeploymentName())) {
        ContainerState state = k8sClientOperator.getContainerState(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector());
        if (state != null) {
            object.put("state", state);
        }
    }
    gdaiDevModel.setCntrMsg(JSON.toJSONString(object));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiDevModelServiceImpl中有一个名为checkGdaiDevModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//查询 修改 true   删除 false
 GdaiDevModel checkGdaiDevModel(User user, Long gdaiDevModelId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiDevModel gdaiDevModel = gdaiDevModelMapper.selectById(gdaiDevModelId);
    if (gdaiDevModel == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiDevModel.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiDevModel.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiDevModel.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiDevModel;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
org.springframework.stereotype.Service
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为queryImageList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryImageList(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.queryImageList params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    Long creatorId = gdaiHarborImageVo.getCreatorId();
    if (creatorId == null) {
        RestResult.genFailResult("creatorId不能为空");
    }
    Long projectId = gdaiHarborImageVo.getProjectId();
    if (projectId == null) {
        RestResult.genFailResult("项目ID不能为空");
    }
    String imageType = gdaiHarborImageVo.getImageType();
    if (StringUtils.isBlank(imageType)) {
        RestResult.genFailResult("镜像类型不能为空");
    }
    String newImageName = gdaiHarborImageVo.getNewImageName();
    String tag = gdaiHarborImageVo.getTag();
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    UiPage<GdaiHarborImageVo> uiPage = new UiPage<>();
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    List<GdaiHarborImageVo> list = new ArrayList<>();
    //先根据imageType判断用户要查询哪种类型的镜像（自定义镜像还是预置镜像）
    Page<GdaiHarborImage> gdaiHarborImagePage = null;
    if ("1".equals(imageType)) {
        //如果查询的是自定义镜像
        //接下来判断用户角色，如果是超管或AI团队管理员则展示该项目下所有成员上传的自定义镜像
        boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
        if (aiGroupAdminRole) {
            EntityWrapper<GdaiHarborImage> wrapper = new EntityWrapper<>();
            wrapper.eq("project_id", projectId).eq("image_type", imageType);
            // 如果newImageName非空，则添加模糊匹配条件
            if (StringUtils.isNotBlank(newImageName)) {
                wrapper.like("new_image_name", newImageName);
            }
            if (StringUtils.isNotBlank(tag)) {
                wrapper.or().like("tag", tag);
            }
            wrapper.orderDesc(desc);
            gdaiHarborImagePage = gdaiHarborImageService.selectPage(new Page<>(gdaiHarborImageVo.getPageNumber(), gdaiHarborImageVo.getPageCount()), wrapper);
        } else {
            EntityWrapper<GdaiHarborImage> wrapper = new EntityWrapper<>();
            wrapper.eq("project_id", projectId).andNew().eq("image_type", imageType).andNew().eq("share_flag", "1").or().eq("creator_id", creatorId);
            // 如果newImageName非空，则添加模糊匹配条件
            if (StringUtils.isNotBlank(newImageName)) {
                wrapper.like("new_image_name", newImageName);
            }
            if (StringUtils.isNotBlank(tag)) {
                wrapper.or().like("tag", tag);
            }
            wrapper.orderDesc(desc);
            //如果用户是普通角色，则展示该用户上传的自定义镜像和该项目共享的镜像
            gdaiHarborImagePage = gdaiHarborImageService.selectPage(new Page<>(gdaiHarborImageVo.getPageNumber(), gdaiHarborImageVo.getPageCount()), wrapper);
        }
    } else if ("2".equals(imageType)) {
        EntityWrapper<GdaiHarborImage> wrapper = new EntityWrapper<>();
        wrapper.eq("image_type", imageType);
        // 如果newImageName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(newImageName)) {
            wrapper.like("new_image_name", newImageName);
        }
        if (StringUtils.isNotBlank(tag)) {
            wrapper.or().like("tag", tag);
        }
        wrapper.orderDesc(desc);
        //如果查询的是预置镜像，无论用户什么角色，则展示所有预置镜像
        gdaiHarborImagePage = gdaiHarborImageService.selectPage(new Page<>(gdaiHarborImageVo.getPageNumber(), gdaiHarborImageVo.getPageCount()), wrapper);
    }
    if (gdaiHarborImagePage != null && gdaiHarborImagePage.getRecords().size() > 0) {
        List<GdaiHarborImage> records = gdaiHarborImagePage.getRecords();
        for (GdaiHarborImage gdaiHarborImage : records) {
            gdaiHarborImageVo = new GdaiHarborImageVo();
            BeanUtils.copyProperties(gdaiHarborImage, gdaiHarborImageVo);
            Long userId = gdaiHarborImage.getCreatorId();
            User userInfo = FeignServiceHelper.getUserInfoById(userClient, userId);
            if (userInfo != null) {
                gdaiHarborImageVo.setCreatorName(userInfo.getUsername());
            }
            list.add(gdaiHarborImageVo);
        }
        uiPage.setTotal(gdaiHarborImagePage.getTotal());
        uiPage.setPageSize(gdaiHarborImagePage.getSize());
        uiPage.setPages(gdaiHarborImagePage.getPages());
        uiPage.setPageNum(gdaiHarborImagePage.getCurrent());
        uiPage.setList(list);
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiHarborImageVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiHarborImageService gdaiHarborImageService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为queryList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryList(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.queryList");
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    String imageFunction = gdaiHarborImageVo.getImageFunction();
    if (StringUtils.isBlank(imageFunction)) {
        RestResult.genFailResult("镜像功能类型不能为空");
    }
    Long projectId = gdaiHarborImageVo.getProjectId();
    if (projectId == null) {
        RestResult.genFailResult("项目ID不能为空");
    }
    String deployPool = gdaiHarborImageVo.getDeployPool();
    if (StringUtils.isBlank(deployPool)) {
        RestResult.genFailResult("资源池不能为空");
    }
    // 查询基础数据
    List<GdaiHarborImage> resultList = CommonTools.isSuperAdminOrAiGroupAdmin(user) ? gdaiHarborImageMapper.selectByImageFunctionV1(imageFunction, projectId) : gdaiHarborImageMapper.selectByImageFunctionV2(imageFunction, projectId, user.getId());
    // 过滤并处理结果
    List<GdaiHarborImage> filteredList = resultList != null ? filterByDeployPool(resultList, deployPool) : Collections.emptyList();
    return RestResult.genSuccessResult(filteredList);
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Collections
java.util.List
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为filterByDeployPool的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private List<GdaiHarborImage> filterByDeployPool(List<GdaiHarborImage> list, String deployPool) {
    List<GdaiHarborImage> filteredList = new ArrayList<>();
    for (GdaiHarborImage image : list) {
        String imagePath = image.getImagePath();
        if (("1".equals(deployPool) && !"icsp/".equals(imagePath)) || ("2".equals(deployPool) && "icsp/".equals(imagePath))) {
            String newName = image.getNewImageName();
            String tag = image.getTag();
            image.setNewImageName(newName + ":" + tag);
            filteredList.add(image);
        }
    }
    return filteredList;
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
java.util.ArrayList
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.add params: [{}]", JSON.toJSONString(gdaiHarborImage));
    try {
        //获取登录用户信息
        User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
        if (user == null) {
            return RestResult.genFailResult("登录用户信息为空");
        }
        Long projectId = gdaiHarborImage.getProjectId();
        Long creatorId = gdaiHarborImage.getCreatorId();
        String imageName = gdaiHarborImage.getImageName();
        String tag = gdaiHarborImage.getTag();
        String startupParameter = gdaiHarborImage.getStartupParameter();
        String shareFlag = gdaiHarborImage.getShareFlag();
        String imageType = gdaiHarborImage.getImageType();
        String newImageName = gdaiHarborImage.getNewImageName();
        String imageFunction = gdaiHarborImage.getImageFunction();
        String imagePath = gdaiHarborImage.getImagePath();
        if (projectId == null) {
            RestResult.genFailResult("项目ID不能为空");
        }
        if (creatorId == null) {
            RestResult.genFailResult("creatorId不能为空");
        }
        if (StringUtils.isBlank(imageName)) {
            return RestResult.genFailResult("镜像名称不能为空");
        }
        if (StringUtils.isBlank(tag)) {
            return RestResult.genFailResult("标签不能为空");
        }
        if (StringUtils.isBlank(shareFlag)) {
            return RestResult.genFailResult("共享标识不能为空");
        }
        if (StringUtils.isBlank(imageType)) {
            return RestResult.genFailResult("镜像类型不能为空");
        }
        if (StringUtils.isBlank(imageFunction)) {
            return RestResult.genFailResult("镜像用途不能为空");
        }
        //判断newImageName是否为空，如果不为空表示镜像已通过后台推送至harbor库，无需调接口进行判断，只需在数据库校验是否已存在对应记录，如果存在则无需新增记录
        if (StringUtils.isBlank(newImageName)) {
            //根据镜像名称、版本号调用harbor api查询该名称的镜像是否在harbor仓库存在，存在则报错提醒
            //先检查harbor仓库是否存在指定项目
            //去除项目名称后的斜杠
            String projectName = imagePath.substring(0, imagePath.length() - 1);
            Long imageProjectId = getProjectIdByHarbor(projectName);
            if (imageProjectId == null) {
                //harbor库项目不存在，则创建该项目
                Boolean bo1 = createProjectByHarbor(projectName);
                if (!bo1) {
                    return RestResult.genFailResult("在harbor库创建指定名称项目失败");
                }
            } else {
                //检查该项目下是否存在对应镜像
                Boolean bo2 = checkImageIsExists(imageProjectId, imageName);
                if (bo2) {
                    //检查该项目下是否存在对应镜像版本
                    Boolean bo3 = checkTagIsExists(imagePath, imageName, tag);
                    if (bo3) {
                        return RestResult.genFailResult("该镜像已存在对应版本，请检查。");
                    }
                }
            }
        }
        //根据imageName，tag，imagePath查询数据库是否存在相同记录，存在则无需新增记录
        GdaiHarborImage harborImage = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(imageName, tag, imagePath));
        if (harborImage != null) {
            return RestResult.genSuccessResult("新增成功");
        }
        if (StringUtils.isBlank(newImageName)) {
            //如果newImageName为空，表示在页面进行镜像上传操作，如果不为空表示镜像已经由后端人员上传只需要将harbor地址填写到数据库中
            String tempFile = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new Date()) + "-" + UuidUtils.uuid();
            String imageTempPath = cephUploadPath + "/" + projectId + "/" + creatorId + GdaiConstant.IMAGE_TEMP_DIR + tempFile;
            gdaiHarborImage.setTempDir(imageTempPath);
            gdaiHarborImage.setStatus("--");
        } else {
            //SPS-镜像推送中 SPE-镜像推送完毕 SPF-镜像推送异常
            gdaiHarborImage.setStatus("SPE");
            //镜像存放在指定harbor项目下
            gdaiHarborImage.setImagePath(imagePath);
        }
        if (StringUtils.isBlank(startupParameter)) {
            //解决字段非空约束,默认赋值为空
            gdaiHarborImage.setStartupParameter("");
        }
        //解决字段非空约束,默认赋值为空
        gdaiHarborImage.setDockerfileContent("");
        gdaiHarborImage.setPushMessage("");
        gdaiHarborImage.setModifierId(creatorId);
        Date date = new Date();
        gdaiHarborImage.setCreateTime(date);
        gdaiHarborImage.setModifyTime(date);
        gdaiHarborImageMapper.insert(gdaiHarborImage);
        return RestResult.genSuccessResult("新增成功");
    } catch (Exception e) {
        log.info("新增异常", e);
        return RestResult.genFailResult("新增异常", e);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.update params: [{}]", JSON.toJSONString(gdaiHarborImage));
    try {
        Long harborImageId = gdaiHarborImage.getHarborImageId();
        Long projectId = gdaiHarborImage.getProjectId();
        String imageName = gdaiHarborImage.getImageName();
        String tag = gdaiHarborImage.getTag();
        String startupParameter = gdaiHarborImage.getStartupParameter();
        Long creatorId = gdaiHarborImage.getCreatorId();
        String imageFunction = gdaiHarborImage.getImageFunction();
        String imagePath = gdaiHarborImage.getImagePath();
        if (harborImageId == null) {
            return RestResult.genFailResult("镜像ID不能为空");
        }
        if (projectId == null) {
            return RestResult.genFailResult("项目ID不能为空");
        }
        if (StringUtils.isBlank(imageName)) {
            return RestResult.genFailResult("镜像名称不能为空");
        }
        if (StringUtils.isBlank(tag)) {
            return RestResult.genFailResult("标签不能为空");
        }
        if (creatorId == null) {
            return RestResult.genFailResult("creatorId不能为空");
        }
        if (StringUtils.isBlank(imageFunction)) {
            return RestResult.genFailResult("镜像用途不能为空");
        }
        if (StringUtils.isBlank(imagePath)) {
            return RestResult.genFailResult("镜像存放项目不能为空");
        }
        GdaiHarborImage image = gdaiHarborImageMapper.selectById(harborImageId);
        if (image == null) {
            return RestResult.genFailResult("该镜像记录不存在");
        }
        //比较传进来的镜像名称和版本号是否和数据库中一致，如果不一致则根据传入的新值去数据库查询是否已存在，如果已存在则提示不能修改
        if (!image.getImageName().equals(imageName) || !image.getTag().equals(tag)) {
            GdaiHarborImage harborImage = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(imageName, tag, imagePath));
            if (harborImage != null) {
                return RestResult.genSuccessResult("该项目下已存在相同版本镜像");
            }
        }
        GdaiHarborImage harborImage = new GdaiHarborImage();
        harborImage.setHarborImageId(harborImageId);
        harborImage.setProjectId(projectId);
        harborImage.setImageName(imageName);
        harborImage.setTag(tag);
        harborImage.setStartupParameter(startupParameter);
        harborImage.setImageFunction(imageFunction);
        harborImage.setImagePath(imagePath);
        harborImage.setModifierId(creatorId);
        harborImage.setModifyTime(new Date());
        gdaiHarborImageMapper.updateById(harborImage);
        return RestResult.genSuccessResult("修改成功");
    } catch (Exception e) {
        log.info("修改异常", e);
        return RestResult.genFailResult("修改异常", e);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为thirdPartySubmit的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult thirdPartySubmit(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.thirdPartySubmit params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    GdaiHarborImage gdaiHarborImage = new GdaiHarborImage();
    BeanUtils.copyProperties(gdaiHarborImageVo, gdaiHarborImage);
    String operationType = gdaiHarborImageVo.getOperationType();
    if (StringUtils.isBlank(operationType)) {
        return RestResult.genFailResult("操作标识不能为空");
    }
    switch(operationType) {
        case "add":
            return thirdPartyAdd(gdaiHarborImage);
        case "update":
            return thirdPartyUpdate(gdaiHarborImage);
        case "delete":
            return thirdPartyDelete(gdaiHarborImage);
        default:
            return RestResult.genFailResult("操作标识错误");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为checkImageIsOwn的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult checkImageIsOwn(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.checkImageIsOwn params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    long userId = user.getId();
    Long harborImageId = gdaiHarborImageVo.getHarborImageId();
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    try {
        //查询该镜像信息
        GdaiHarborImage harborImage = gdaiHarborImageMapper.selectById(harborImageId);
        if (harborImage == null) {
            return RestResult.genSuccessResult("未查询到该镜像信息");
        }
        if (harborImage.getCreatorId() == userId) {
            return RestResult.genSuccessResult("该镜像属于当前用户", true);
        } else {
            return RestResult.genSuccessResult("该镜像不属于当前用户", false);
        }
    } catch (Exception e) {
        return RestResult.genFailResult("校验异常", e);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiHarborImage gdaiHarborImage) throws TrainginCenterException {
    log.info("GdaiHarborImageServiceImpl.updateShareFlag params: [{}]", JSON.toJSONString(gdaiHarborImage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long harborImageId = gdaiHarborImage.getHarborImageId();
    String shareFlag = gdaiHarborImage.getShareFlag();
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    checkGdaiHarborImage(user, harborImageId, false);
    GdaiHarborImage image = new GdaiHarborImage();
    image.setHarborImageId(harborImageId);
    image.setShareFlag(shareFlag);
    image.setModifyTime(new Date());
    gdaiHarborImageMapper.updateById(image);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为checkFileMd5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> checkFileMd5(String md5, String fileName, String tempDir) {
    log.info("GdaiHarborImageServiceImpl.checkFileMd5 params: [{}],[{}]", fileName, tempDir);
    try {
        Result result = LocalUpload.checkFileMd5(md5, fileName, tempDir + GdaiConstant.BREAK_POINT_CONF_PATH, tempDir + GdaiConstant.BREAK_POINT_PATH);
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("MD5检查异常", e);
    }
    return RestResult.genFailResult("MD5检查异常");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为breakpointUpload的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> breakpointUpload(GdaiHarborImageVo gdaiHarborImageVo, HttpServletRequest request) {
    log.info("GdaiHarborImageServiceImpl.breakpointUpload params: [{}],[{}],[{}],[{}],[{}]", gdaiHarborImageVo.getId(), gdaiHarborImageVo.getChunks(), gdaiHarborImageVo.getChunk(), gdaiHarborImageVo.getSize(), gdaiHarborImageVo.getName());
    try {
        //获取断点续传参数
        String id = gdaiHarborImageVo.getId();
        int chunks = gdaiHarborImageVo.getChunks();
        int chunk = gdaiHarborImageVo.getChunk();
        long size = gdaiHarborImageVo.getSize();
        String name = gdaiHarborImageVo.getName();
        MultipartFile file = gdaiHarborImageVo.getFile();
        String md5 = gdaiHarborImageVo.getMd5();
        //获取上传根目录
        String tempDir = gdaiHarborImageVo.getTempDir();
        //拼装上传压缩包目录
        String filePath = tempDir + GdaiConstant.BREAK_POINT_PATH;
        String confFilePath = tempDir + GdaiConstant.BREAK_POINT_CONF_PATH;
        // 这里的 chunkSize(分片大小) 要与前端传过来的大小一致
        Result result = LocalUpload.fragmentFileUploader(new UploadFileParam(id, chunks, chunk, size, name, file, md5), confFilePath, filePath, 5242880L, request);
        result.setData(filePath);
        //            String code = result.getCode();
        //            //状态码为201时表示文件上传完毕，此时对压缩包进行校验
        //            if ("201".equals(code)) {
        //                //对压缩包进行合法性检查
        //                String srcZipPath = filePath + "/" + name;
        //                //添加不允许的扩展名
        //                String[] fileTypesArray = disallowedFileType2Tar.split(",");
        //                // 转换字符串数组为List
        //                List<String> disallowedExtensions = Arrays.stream(fileTypesArray).map(String::trim).collect(Collectors.toList());
        //                boolean isValid = FileUtil.validateTarFileContainsDisallowedFileTypes(srcZipPath, disallowedExtensions);
        //                if (!isValid) {
        //                    //校验不通过删除压缩包
        //                    String filePathTemp = filePath + "/" + name;
        //                    String confFilePathTemp = confFilePath + "/" + name + ".conf";
        //                    if (StringUtils.isNotBlank(filePathTemp)) {
        //                        File files = FileUtils.getFile(filePathTemp);
        //                        if (files.exists()) {
        //                            FileUtil.deleteFile(files);
        //                        }
        //                    }
        //                    if (StringUtils.isNotBlank(confFilePathTemp)) {
        //                        File confFile = FileUtils.getFile(confFilePathTemp);
        //                        if (confFile.exists()) {
        //                            FileUtil.deleteFile(confFile);
        //                        }
        //                    }
        //                    return RestResult.genFailResult("压缩包为空或者压缩包中包含不允许的文件类型,请删除后重新上传");
        //                }
        //            }
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("镜像上传异常", e);
        return RestResult.genFailResult("镜像上传异常", e);
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
com.eshore.gdai.trainingcenter.vo.UploadFileParam
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.List
### 类级别的变量
@Autowired
private HttpServletRequest request;
/**
 * 不允许上传的文件类型
 */
@Value("${upload.disallowedFileType2Tar}")
private String disallowedFileType2Tar;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为deleteBreakpointFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteBreakpointFile(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.deleteBreakpointFile params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    String fileName = gdaiHarborImageVo.getName();
    String tempDir = gdaiHarborImageVo.getTempDir();
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("文件名称不能为空");
    }
    if (StringUtils.isBlank(tempDir)) {
        return RestResult.genFailResult("镜像压缩包存放路径不能为空");
    }
    try {
        //拼装文件完整路径
        String filePath = tempDir + GdaiConstant.BREAK_POINT_PATH + "/" + fileName;
        String confFilePath = tempDir + GdaiConstant.BREAK_POINT_CONF_PATH + "/" + fileName + ".conf";
        if (StringUtils.isNotBlank(filePath)) {
            File file = FileUtils.getFile(filePath);
            if (file.exists()) {
                FileUtil.deleteFile(file);
            }
        }
        if (StringUtils.isNotBlank(confFilePath)) {
            File confFile = FileUtils.getFile(confFilePath);
            if (confFile.exists()) {
                FileUtil.deleteFile(confFile);
            }
        }
    } catch (Exception e) {
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为saveImageInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult saveImageInfo(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.saveImageInfo params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    Long harborImageId = gdaiHarborImageVo.getHarborImageId();
    String fileName = gdaiHarborImageVo.getFileName();
    String imageName = gdaiHarborImageVo.getImageName();
    String imagePath = gdaiHarborImageVo.getImagePath();
    String tempDir = gdaiHarborImageVo.getTempDir();
    String tag = gdaiHarborImageVo.getTag();
    Long projectId = gdaiHarborImageVo.getProjectId();
    Long creatorId = gdaiHarborImageVo.getCreatorId();
    if (harborImageId == null) {
        RestResult.genFailResult("镜像ID不能为空");
    }
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("镜像压缩包名称不能为空");
    }
    if (StringUtils.isBlank(imageName)) {
        return RestResult.genFailResult("镜像名称不能为空");
    }
    if (StringUtils.isBlank(imagePath)) {
        return RestResult.genFailResult("镜像存放harbor项目不能为空");
    }
    if (StringUtils.isBlank(tempDir)) {
        return RestResult.genFailResult("镜像压缩包存放路径不能为空");
    }
    if (StringUtils.isBlank(tag)) {
        return RestResult.genFailResult("标签不能为空");
    }
    if (projectId == null) {
        RestResult.genFailResult("项目ID不能为空");
    }
    if (creatorId == null) {
        RestResult.genFailResult("creatorId不能为空");
    }
    try {
        gdaiHarborImageMapper.updateById(new GdaiHarborImage(harborImageId, "SPS", new Date()));
        gdaiHarborImageAsyncTask.startPushImage(gdaiHarborImageVo);
    } catch (Exception e) {
        log.info("开始推送镜像异常", e);
        return RestResult.genFailResult("开始推送镜像异常", e);
    }
    return RestResult.genSuccessResult("开始推送镜像");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Resource
private GdaiHarborImageAsyncTask gdaiHarborImageAsyncTask;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为getImageId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取镜像压缩包中的镜像ID
     *
     * @param ext
     * @param file
     * @return
     * @throws Exception
     */
public static String getImageId(String ext, File file) throws Exception {
    if (".tar".equalsIgnoreCase(ext)) {
        return getImageIdByTar(file);
    } else if (".tar.gz".equalsIgnoreCase(ext)) {
        return getImageIdByTarGz(file);
    } else {
        throw new Exception("不支持该类型镜像压缩包");
    }
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为getImageIdByTar的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String getImageIdByTar(File file) throws IOException {
    try (FileInputStream fis = new FileInputStream(file);
        TarInputStream tin = new TarInputStream(fis)) {
        TarEntry entry;
        while ((entry = tin.getNextEntry()) != null) {
            String entryName = entry.getName();
            if ("manifest.json".equals(entryName)) {
                JsonNode manifestJson = objectMapper.readTree(tin);
                JsonNode configRef = manifestJson.get(0).get("Config");
                if (configRef.isTextual()) {
                    String configPath = configRef.asText();
                    if (configPath.endsWith(".json")) {
                        return configPath.substring(0, configPath.length() - 5);
                    }
                }
            }
        }
        throw new IOException("manifest.json not found in the tar file");
    }
}
### 类导入的包
com.fasterxml.jackson.databind.JsonNode
org.apache.tools.tar.TarEntry
org.apache.tools.tar.TarInputStream
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
### 类级别的变量
private static final ObjectMapper objectMapper = new ObjectMapper();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为getImageIdByTarGz的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String getImageIdByTarGz(File file) throws IOException {
    try (FileInputStream fis = new FileInputStream(file);
        TarArchiveInputStream tin = new TarArchiveInputStream(new GzipCompressorInputStream(fis))) {
        TarArchiveEntry entry;
        while ((entry = tin.getNextTarEntry()) != null) {
            String entryName = entry.getName();
            if ("manifest.json".equals(entryName)) {
                JsonNode manifestJson = objectMapper.readTree(tin);
                JsonNode configRef = manifestJson.get(0).get("Config");
                if (configRef.isTextual()) {
                    String configPath = configRef.asText();
                    if (configPath.endsWith(".json")) {
                        return configPath.substring(0, configPath.length() - 5);
                    }
                }
            }
        }
        throw new IOException("manifest.json not found in the tar.gz file");
    }
}
### 类导入的包
com.fasterxml.jackson.databind.JsonNode
org.apache.commons.compress.archivers.tar.TarArchiveEntry
org.apache.commons.compress.archivers.tar.TarArchiveInputStream
org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
org.apache.tools.tar.TarEntry
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
### 类级别的变量
private static final ObjectMapper objectMapper = new ObjectMapper();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为queryImageByCondition的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryImageByCondition(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.queryImageByCondition params: [{}]", JSON.toJSONString(gdaiHarborImage));
    String imageName = gdaiHarborImage.getImageName();
    String tag = gdaiHarborImage.getTag();
    String imagePath = gdaiHarborImage.getImagePath();
    if (StringUtils.isBlank(imageName)) {
        return RestResult.genFailResult("镜像名称不能为空");
    }
    if (StringUtils.isBlank(tag)) {
        return RestResult.genFailResult("标签不能为空");
    }
    if (StringUtils.isBlank(imagePath)) {
        return RestResult.genFailResult("镜像存放项目不能为空");
    }
    GdaiHarborImage harborImage;
    try {
        //上传之前查询该进镜像是否已经存在
        harborImage = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(imageName, tag, imagePath));
        if (harborImage != null) {
            return RestResult.genFailResult("该镜像已存在");
        }
    } catch (Exception e) {
        log.info("查询镜像信息异常", e);
        return RestResult.genFailResult("查询镜像信息异常");
    }
    return RestResult.genSuccessResult(harborImage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为queryImageById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryImageById(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.queryImageById params: [{}]", JSON.toJSONString(gdaiHarborImage));
    Long harborImageId = gdaiHarborImage.getHarborImageId();
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    GdaiHarborImage harborImage;
    try {
        //查询该进镜像记录是否已经存在
        //修复水平越权问题
        harborImage = checkGdaiHarborImage(user, harborImageId, true);
    } catch (Exception e) {
        log.info("查询镜像信息异常", e);
        return RestResult.genFailResult("查询镜像信息异常");
    }
    return RestResult.genSuccessResult(harborImage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为thirdPartyQueryImageById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult thirdPartyQueryImageById(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.thirdPartyQueryImageById params: [{}]", JSON.toJSONString(gdaiHarborImage));
    Long harborImageId = gdaiHarborImage.getHarborImageId();
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    GdaiHarborImage harborImage;
    try {
        harborImage = gdaiHarborImageMapper.selectById(harborImageId);
    } catch (Exception e) {
        log.info("查询镜像信息异常", e);
        return RestResult.genFailResult("查询镜像信息异常");
    }
    return RestResult.genSuccessResult(harborImage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiHarborImage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long harborImageId = gdaiHarborImage.getHarborImageId();
    if (harborImageId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    String tempDir = null;
    try {
        //修复水平越权问题
        GdaiHarborImage harborImage = checkGdaiHarborImage(user, harborImageId, false);
        tempDir = harborImage.getTempDir();
        String status = harborImage.getStatus();
        if (StringUtils.isNotBlank(status) && "SPF".equals(status)) {
            gdaiHarborImageMapper.deleteById(harborImageId);
            return RestResult.genSuccessResult("删除成功");
        }
        String newName = harborImage.getNewImageName();
        if (StringUtils.isNotBlank(newName)) {
            String imageName = harborImage.getImageName();
            String orgTag = harborImage.getTag();
            String imagePath = harborImage.getImagePath();
            Long projectId = harborImage.getProjectId();
            // 解析新镜像名
            // 使用正则表达式匹配
            Pattern pattern = Pattern.compile("^(?:[^:/]+:)?([^/]+)/(.+?)(?::([^/]+))?$");
            Matcher matcher = pattern.matcher(newName);
            if (matcher.matches()) {
                // 检查是否有其他项目在使用该镜像
                List<GdaiHarborImage> gdaiHarborImages = gdaiHarborImageMapper.selectList(new EntityWrapper<GdaiHarborImage>().eq("image_name", imageName).eq("tag", orgTag).eq("image_path", imagePath).ne("project_id", projectId));
                if (gdaiHarborImages.isEmpty()) {
                    //判断harbor库镜像是否存在
                    //检查该项目下是否存在对应镜像版本
                    Boolean bo = checkTagIsExists(imagePath, imageName, orgTag);
                    if (bo) {
                        // 如果没有其他项目使用，则调用API删除镜像
                        String path = imagePath + imageName;
                        String url = String.format(deleteByTagUrl, path, orgTag);
                        String result = httpRequest(url, HttpMethod.DELETE, null);
                        if (HttpStatus.SC_OK == Integer.parseInt(result)) {
                            // 如果API调用成功，则删除本地记录
                            gdaiHarborImageMapper.deleteById(harborImageId);
                        } else {
                            // 记录删除失败的信息
                            log.info("从harbor库删除镜像失败. 返回信息: [{}]", result);
                        }
                    } else {
                        log.info("该镜像harbor库不存在，删除本项目下数据库记录");
                        gdaiHarborImageMapper.deleteById(harborImageId);
                    }
                } else {
                    // 如果有其他项目使用，执行删除操作，记录日志
                    log.info("镜像有其他项目在用，只删除本项目下镜像记录，不删除harbor库镜像");
                    gdaiHarborImageMapper.deleteById(harborImageId);
                }
            } else {
                log.info("镜像名称正则校验不通过，直接删除: [{}]", newName);
                gdaiHarborImageMapper.deleteById(harborImageId);
            }
        } else {
            log.info("镜像名称为空，直接删除");
            gdaiHarborImageMapper.deleteById(harborImageId);
        }
    } catch (Exception e) {
        log.info("删除镜像信息异常", e);
        return RestResult.genFailResult("删除镜像信息异常");
    } finally {
        //上传完毕删除临时文件及文件夹
        if (StringUtils.isNotBlank(tempDir)) {
            File filePath = FileUtils.getFile(tempDir);
            if (filePath.exists()) {
                FileUtil.deleteFile(filePath);
            }
        }
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.apache.http.HttpStatus
org.springframework.http.HttpMethod
org.springframework.stereotype.Service
java.io.File
java.util.List
java.util.regex.Matcher
java.util.regex.Pattern
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Autowired
private HttpServletRequest request;
/**
 * Harbor库根据tag删除镜像API
 */
@Value("${harbor-api.deleteByTagUrl}")
private String deleteByTagUrl;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为uploadPrepareFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult uploadPrepareFile(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.uploadPrepareFile");
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long projectId = gdaiHarborImageVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    List<MultipartFile> files = gdaiHarborImageVo.getFiles();
    String destDirPath = "";
    String zipPath = "";
    try {
        for (MultipartFile next : files) {
            String originalFilename = next.getOriginalFilename();
            String ext = FilenameUtils.getExtension(next.getOriginalFilename());
            //创建临时目录
            String tempFile = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new Date()) + "-" + UuidUtils.uuid();
            String prepareFilePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.LOCAL_DOCKERFILE + "/" + tempFile;
            cn.hutool.core.io.FileUtil.mkdir(prepareFilePath);
            //临时地址
            destDirPath = prepareFilePath + "/temp";
            cn.hutool.core.io.FileUtil.mkdir(destDirPath);
            //上传时需要区分文件是否为压缩包
            if ("zip".equalsIgnoreCase(ext)) {
                File prepareFile = FileUtils.getFile(prepareFilePath + "/" + originalFilename);
                //上传文件
                next.transferTo(prepareFile);
                //读取压缩文件内容
                zipPath = prepareFile.getAbsolutePath();
                Set<String> set = ZipUtil.readZip(zipPath, destDirPath, prepareFilePath);
                if (set == null || set.size() == 0) {
                    return RestResult.genFailResult("读取压缩文件失败");
                }
            } else {
                File prepareFile = FileUtils.getFile(destDirPath + "/" + originalFilename);
                next.transferTo(prepareFile);
            }
        }
    } catch (Exception e) {
        log.info("上传文件异常", e);
    } finally {
        if (StringUtils.isNotBlank(zipPath)) {
            File zipFile = FileUtils.getFile(zipPath);
            if (zipFile.exists()) {
                FileUtil.deleteFile(zipFile);
            }
        }
    }
    if (StringUtils.isNotBlank(destDirPath)) {
        return RestResult.genSuccessResult(destDirPath);
    } else {
        return RestResult.genFailResult("上传文件异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.io.FilenameUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.web.multipart.MultipartFile
java.io.File
java.nio.file.Files
java.text.SimpleDateFormat
java.util.Date
java.util.List
java.util.Set
### 类级别的变量
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为createImage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult createImage(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.createImage params: [{}]", JSON.toJSONString(gdaiHarborImage));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long projectId = gdaiHarborImage.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String dockerfileContent = gdaiHarborImage.getDockerfileContent();
    if (StringUtils.isBlank(dockerfileContent)) {
        return RestResult.genFailResult("Dockerfile内容不能为空");
    }
    Long userId = user.getId();
    String tag = gdaiHarborImage.getTag();
    String shortName = gdaiHarborImage.getShortName();
    String imageName = gdaiHarborImage.getImageName();
    String imagePath = gdaiHarborImage.getImagePath();
    String prepareFilePath = gdaiHarborImage.getPrepareFilePath();
    String shareFlag = gdaiHarborImage.getShareFlag();
    try {
        if (StringUtils.isBlank(prepareFilePath)) {
            //prepareFilePath目录为空说明用户未上传文件拷贝至容器内，此时创建临时目录用来生成Dockerfile
            String tempFile = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new Date()) + "-" + UuidUtils.uuid();
            prepareFilePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.LOCAL_DOCKERFILE + "/" + tempFile + "/temp";
        }
        //创建临时目录，生成Dockerfile
        String dockerfilePath = FileUtil.removeLastDirectoryFromPath(prepareFilePath);
        cn.hutool.core.io.FileUtil.mkdir(dockerfilePath);
        InputStream is = new ByteArrayInputStream(dockerfileContent.getBytes());
        String DockerfileName = dockerfilePath + "/Dockerfile";
        File Dockerfile = FileUtils.getFile(DockerfileName);
        Files.copy(is, Dockerfile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        //拼装镜像名称
        String buildImageName = IP + ":" + PORT + "/" + imagePath + imageName;
        //落库之前查询该项目下是否存在同名或者同版本的镜像
        GdaiHarborImage gdaiHarborImage1 = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(imageName, tag, imagePath));
        if (gdaiHarborImage1 != null) {
            //删除创建的临时目录
            if (StringUtils.isNotBlank(prepareFilePath)) {
                String substring = prepareFilePath.substring(0, prepareFilePath.lastIndexOf("temp"));
                File filePath = FileUtils.getFile(substring);
                if (filePath.exists()) {
                    FileUtil.deleteFile(filePath);
                }
            }
            return RestResult.genSuccessResult("该项目下已存在相同版本镜像");
        }
        //根据镜像名称、版本号调用harbor api查询该名称的镜像是否在harbor仓库存在，存在则报错提醒
        //先检查harbor仓库是否存在指定项目
        //去除项目名称后的斜杠
        String projectName = imagePath.substring(0, imagePath.length() - 1);
        Long imageProjectId = getProjectIdByHarbor(projectName);
        if (imageProjectId == null) {
            //harbor库项目不存在，则创建该项目
            Boolean bo1 = createProjectByHarbor(projectName);
            if (!bo1) {
                return RestResult.genFailResult("在harbor库创建指定名称项目失败");
            }
        } else {
            //检查该项目下是否存在对应镜像
            Boolean bo2 = checkImageIsExists(imageProjectId, imageName);
            if (bo2) {
                Boolean bo3 = checkTagIsExists(imagePath, imageName, tag);
                if (bo3) {
                    return RestResult.genFailResult("该镜像已存在对应版本，请检查。");
                }
            }
        }
        Date date = new Date();
        GdaiHarborImage harborImage = new GdaiHarborImage(projectId, imageName, buildImageName, tag, imagePath, "SPS", shortName, dockerfileContent, prepareFilePath, "", shareFlag, userId, date, userId, date);
        gdaiHarborImageMapper.insert(harborImage);
        Long harborImageId = harborImage.getHarborImageId();
        //另起线程创建镜像并推送至harbor库
        GdaiHarborImageServiceImpl gdaiHarborImageServiceImpl = new GdaiHarborImageServiceImpl();
        uploadThreadPool.execute(new StartCreateImage(gdaiHarborImageMapper, gdaiHarborImageServiceImpl, Dockerfile, buildImageName, tag, harborImageId, prepareFilePath, HARBOR_LOGIN_ADDRESS, HARBOR_USERNAME, HARBOR_PASSWORD));
    } catch (Exception e) {
        log.info("创建镜像异常:", e);
    }
    return RestResult.genSuccessResult("创建镜像中");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.ByteArrayInputStream
java.io.File
java.io.InputStream
java.nio.file.Files
java.nio.file.StandardCopyOption
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Resource
private GdaiHarborImageService gdaiHarborImageService;
@Autowired
private HttpServletRequest request;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
/**
 * cephfs挂载目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;
/**
 * Harbor登录用户名
 */
@Value("${harbor.username}")
private String HARBOR_USERNAME;
/**
 * 登录密码
 */
@Value("${harbor.password}")
private String HARBOR_PASSWORD;
/**
 * Harbor的登录地址
 */
@Value("${harbor.login_address}")
private String HARBOR_LOGIN_ADDRESS;
/**
 * Harbor的登录地址
 */
@Value("${harbor.ip}")
private String IP;
/**
 * Harbor的登录地址
 */
@Value("${harbor.port}")
private String PORT;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为pushImageToHarbor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public boolean pushImageToHarbor(File file, String newImageName, String repoTags, String tag, String harborLoginAddress, String harborUsername, String harborPassword) throws TrainginCenterException {
    log.info("上传镜像文件时，传递的参数: [{}],[{}],[{}],[{}]", file.getAbsolutePath(), newImageName, harborLoginAddress, tag);
    try (InputStream inputStream = new FileInputStream(file)) {
        DockerClient dockerClient = getDockerClient();
        //Harbor登录信息
        AuthConfig autoConfig = new AuthConfig().withRegistryAddress(harborLoginAddress).withUsername(harborUsername).withPassword(harborPassword);
        //加载镜像
        log.info("====开始加载镜像====");
        dockerClient.loadImageCmd(inputStream).exec();
        log.info("====加载镜像成功====");
        //            String uploadImageName = "";
        //            List<Image> list = dockerClient.listImagesCmd().exec();
        //            for (Image image : list) {
        //                if (image.getId().contains(imageId)) {
        //                    if (image.getRepoTags() != null && image.getRepoTags().length > 0) {
        //                        uploadImageName = image.getRepoTags()[0];
        //                        break;
        //                    } else {
        //                        // 如果没有标签，可以选择记录日志或进行其他处理
        //                        log.info("镜像 " + imageId + " 存在但没有标签");
        //                    }
        //                }
        //            }
        //            // 检查是否成功找到镜像名称
        //            if (uploadImageName.isEmpty()) {
        //                log.info("未找到镜像 " + imageId);
        //            } else {
        //                log.info("找到的镜像名称为: " + uploadImageName);
        //            }
        String uploadImageName = repoTags;
        //给镜像打上tag
        log.info("原始镜像名: [{}], 要修改的镜像名: [{}]", uploadImageName, newImageName);
        if ("<none>:<none>".equals(uploadImageName) || StringUtils.isBlank(uploadImageName)) {
            //dockerClient.tagImageCmd(imageId, newImageName, tag).exec();
            dockerClient.tagImageCmd(uploadImageName, newImageName, tag).exec();
        } else {
            dockerClient.tagImageCmd(uploadImageName, newImageName, tag).exec();
        }
        //推送镜像至镜像仓库
        dockerClient.pushImageCmd(newImageName).withAuthConfig(autoConfig).start().awaitCompletion();
        log.info("====推送镜像成功====");
        //push成功后，删除本地加载的镜像
        dockerClient.removeImageCmd(newImageName).exec();
        if ("<none>:<none>".equals(uploadImageName) || StringUtils.isBlank(uploadImageName)) {
            //dockerClient.removeImageCmd(imageId).exec();
            dockerClient.removeImageCmd(uploadImageName).exec();
        } else {
            dockerClient.removeImageCmd(uploadImageName).exec();
        }
        log.info("====删除本地镜像成功====");
        return true;
    } catch (Exception e) {
        log.info("推送镜像到镜像仓库异常: {}", e);
        throw new TrainginCenterException("推送镜像到镜像仓库异常: " + e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.github.dockerjava.api.DockerClient
com.github.dockerjava.api.model.AuthConfig
org.apache.commons.lang3.StringUtils
java.io.File
java.io.FileInputStream
java.io.InputStream
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为catFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult catFile(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.catFile params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    Long harborImageId = gdaiHarborImageVo.getHarborImageId();
    String md5 = gdaiHarborImageVo.getMd5();
    String tempDir = gdaiHarborImageVo.getTempDir();
    String partPrefix = gdaiHarborImageVo.getPartPrefix();
    String fileName = gdaiHarborImageVo.getFileName();
    String ext = gdaiHarborImageVo.getExt();
    List<String> fileNameList = gdaiHarborImageVo.getFileNameList();
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    if (StringUtils.isBlank(md5)) {
        return RestResult.genFailResult("原文件MD5不能为空");
    }
    if (StringUtils.isBlank(tempDir)) {
        return RestResult.genFailResult("文件分片存储路径不能为空");
    }
    if (StringUtils.isBlank(partPrefix)) {
        return RestResult.genFailResult("文件前缀不能为空");
    }
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("压缩包名称不能为空");
    }
    if (StringUtils.isBlank(ext)) {
        return RestResult.genFailResult("压缩包后缀不能为空");
    }
    if (fileNameList == null) {
        return RestResult.genFailResult("分片文件集合不能为空");
    }
    try {
        //修改状态：SFC-文件合并校验中
        gdaiHarborImageMapper.updateById(new GdaiHarborImage(harborImageId, "SFC", new Date()));
        //异步执行文件和并合及MD5校验操作
        gdaiHarborImageAsyncTask.startCatFile(gdaiHarborImageVo);
    } catch (Exception e) {
        log.info("文件合并异常", e);
        return RestResult.genFailResult("文件合并异常", e);
    }
    return RestResult.genSuccessResult("开始文件合并");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Resource
private GdaiHarborImageAsyncTask gdaiHarborImageAsyncTask;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为queryFileByPath的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryFileByPath(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.queryFileByPath params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    String tempDir = gdaiHarborImageVo.getTempDir();
    if (StringUtils.isBlank(tempDir)) {
        return RestResult.genFailResult("文件分片存储路径不能为空");
    }
    try {
        //拼装tempDir为json类型
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("path", tempDir);
        List<DirOrFileInfoVo> dirOrFileInfoVos = girOrFileInfoService.printFilesAndDirectories(jsonObject);
        if (dirOrFileInfoVos != null && dirOrFileInfoVos.size() > 0) {
            return RestResult.genSuccessResult(dirOrFileInfoVos);
        } else {
            return RestResult.genSuccessResult("查询为空", dirOrFileInfoVos);
        }
    } catch (Exception e) {
        log.info("查询异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.DirOrFileInfoVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.nio.file.Files
java.util.List
### 类级别的变量
@Resource
private DirOrFileInfoService girOrFileInfoService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为performOperationFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult performOperationFile(GdaiHarborImageVo gdaiHarborImageVo) {
    log.info("GdaiHarborImageServiceImpl.performOperationFile params: [{}]", JSON.toJSONString(gdaiHarborImageVo));
    String operationType = gdaiHarborImageVo.getOperationType();
    String tempDir = gdaiHarborImageVo.getTempDir();
    if (StringUtils.isBlank(operationType)) {
        return RestResult.genFailResult("文件操作类型不能为空");
    }
    if (StringUtils.isBlank(tempDir)) {
        return RestResult.genFailResult("文件分片存储路径不能为空");
    }
    //拼装tempDir为json类型
    JSONObject jsonObject = new JSONObject();
    jsonObject.put("operationType", operationType);
    jsonObject.put("sourcePath", tempDir);
    Boolean aBoolean = girOrFileInfoService.performOperation(jsonObject);
    if (aBoolean) {
        String tempDirConf = tempDir.replace("fileManager", "conf");
        //文件删除成功继续删除分片上传时记录下的分片记录文件
        File filePath = FileUtils.getFile(tempDirConf + ".conf");
        if (filePath.exists()) {
            FileUtil.deleteFile(tempDirConf + ".conf");
        }
    }
    if (aBoolean) {
        return RestResult.genSuccessResult("文件操作成功");
    } else {
        return RestResult.genFailResult("文件操作成功");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量
@Resource
private DirOrFileInfoService girOrFileInfoService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为calculateMD5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取MD5
     *
     * @param filePath
     * @return
     */
public static String calculateMD5(String filePath) {
    File file = new File(filePath);
    if (!file.exists() || !file.isFile()) {
        log.info("File does not exist or is not a file: " + filePath);
        return null;
    }
    String command = "md5sum " + file.getAbsolutePath();
    ProcessBuilder processBuilder = new ProcessBuilder("sh", "-c", command);
    Process process = null;
    String md5Hash = null;
    try {
        process = processBuilder.start();
        // 捕获命令的输出
        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line;
        if ((line = reader.readLine()) != null) {
            // md5sum命令的输出格式是 "md5_hash  filename"，我们只需要md5_hash部分
            String[] parts = line.split("\\s+");
            if (parts.length > 0) {
                md5Hash = parts[0];
            }
        }
        // 等待命令执行完成并获取退出码
        int exitCode = process.waitFor();
        if (exitCode != 0) {
            log.info("Command failed with exit code: " + exitCode);
            md5Hash = null;
        }
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
        md5Hash = null;
    } finally {
        if (process != null && process.isAlive()) {
            process.destroy();
        }
    }
    return md5Hash;
}
### 类导入的包
java.io.BufferedReader
java.io.File
java.io.IOException
java.io.InputStream
java.io.InputStreamReader
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为getDockerClient的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取dockerClient对象
     */
public DockerClient getDockerClient() {
    //创建DefaultDockerClientConfig（当前服务器的默认配置）
    DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().build();
    //创建DockerHttpClient
    DockerHttpClient httpClient = new ApacheDockerHttpClient.Builder().dockerHost(config.getDockerHost()).maxConnections(100).connectionTimeout(Duration.ofSeconds(30)).responseTimeout(Duration.ofSeconds(45)).build();
    //创建DockerClient
    return DockerClientImpl.getInstance(config, httpClient);
}
### 类导入的包
com.github.dockerjava.api.DockerClient
com.github.dockerjava.core.DefaultDockerClientConfig
com.github.dockerjava.core.DockerClientImpl
com.github.dockerjava.httpclient5.ApacheDockerHttpClient
com.github.dockerjava.transport.DockerHttpClient
java.time.Duration
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为httpRequest的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private String httpRequest(String url, HttpMethod method, String requestBody) throws Exception {
    // 创建一个信任所有的SSL上下文
    TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {

        @Override
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        @Override
        public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
        }

        @Override
        public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
        }
    } };
    HttpRequestBase request = getRequest(url, method);
    request.addHeader("authorization", getAuthorization());
    if (StringUtils.isNotEmpty(requestBody)) {
        StringEntity stringEntity = new StringEntity(requestBody, "UTF-8");
        stringEntity.setContentType("application/json;charset=UTF-8");
        ((HttpEntityEnclosingRequestBase) request).setEntity(stringEntity);
    }
    try {
        SSLContext sc = SSLContext.getInstance("SSL");
        // 初始化SSL上下文
        sc.init(null, trustAllCerts, new SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        try (CloseableHttpClient client = HttpClientBuilder.create().setSSLContext(sc).build()) {
            try (CloseableHttpResponse response = client.execute(request)) {
                int statusCode = response.getStatusLine().getStatusCode();
                return String.valueOf(statusCode);
            }
        }
    } catch (Exception e) {
        throw new Exception(e.getMessage());
    }
}
### 类导入的包
org.apache.commons.lang3.StringUtils
org.apache.http.client.methods.CloseableHttpResponse
org.apache.http.client.methods.HttpEntityEnclosingRequestBase
org.apache.http.client.methods.HttpRequestBase
org.apache.http.entity.StringEntity
org.apache.http.impl.client.CloseableHttpClient
org.apache.http.impl.client.HttpClientBuilder
javax.net.ssl.HttpsURLConnection
javax.net.ssl.SSLContext
javax.net.ssl.TrustManager
javax.net.ssl.X509TrustManager
java.security.SecureRandom
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为httpRequestV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private String httpRequestV2(String url, HttpMethod method, String requestBody) throws Exception {
    // 创建一个信任所有的SSL上下文
    TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {

        @Override
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        @Override
        public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
        }

        @Override
        public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
        }
    } };
    HttpRequestBase request = getRequest(url, method);
    request.addHeader("authorization", getAuthorization());
    if (StringUtils.isNotEmpty(requestBody)) {
        StringEntity stringEntity = new StringEntity(requestBody, "UTF-8");
        stringEntity.setContentType("application/json;charset=UTF-8");
        ((HttpEntityEnclosingRequestBase) request).setEntity(stringEntity);
    }
    try {
        SSLContext sc = SSLContext.getInstance("SSL");
        // 初始化SSL上下文
        sc.init(null, trustAllCerts, new SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        try (CloseableHttpClient client = HttpClientBuilder.create().setSSLContext(sc).build()) {
            try (CloseableHttpResponse response = client.execute(request)) {
                // 检查响应状态码
                if (response.getStatusLine().getStatusCode() == 200) {
                    // 读取响应体
                    String responseBody = EntityUtils.toString(response.getEntity(), "UTF-8");
                    if (StringUtils.isEmpty(responseBody) || "null".equals(responseBody) || "[]".equals(responseBody) || "{}".equals(responseBody)) {
                        return null;
                    }
                    // 在这里处理responseBody
                    return responseBody;
                } else {
                    // 处理非200响应
                    throw new Exception("Response status code: " + response.getStatusLine().getStatusCode());
                }
            }
        }
    } catch (Exception e) {
        throw new Exception(e.getMessage());
    }
}
### 类导入的包
org.apache.commons.lang3.StringUtils
org.apache.http.client.methods.CloseableHttpResponse
org.apache.http.client.methods.HttpEntityEnclosingRequestBase
org.apache.http.client.methods.HttpRequestBase
org.apache.http.entity.StringEntity
org.apache.http.impl.client.CloseableHttpClient
org.apache.http.impl.client.HttpClientBuilder
org.apache.http.util.EntityUtils
javax.net.ssl.HttpsURLConnection
javax.net.ssl.SSLContext
javax.net.ssl.TrustManager
javax.net.ssl.X509TrustManager
java.security.SecureRandom
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为getRequest的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private HttpRequestBase getRequest(String url, HttpMethod method) {
    switch(method) {
        case GET:
            return new HttpGet(url);
        case POST:
            return new HttpPost(url);
        case DELETE:
            return new HttpDelete(url);
        default:
            throw new IllegalArgumentException("Unsupported method");
    }
}
### 类导入的包
org.apache.http.client.methods.HttpDelete
org.apache.http.client.methods.HttpGet
org.apache.http.client.methods.HttpPost
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为checkGdaiHarborImage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiHarborImage checkGdaiHarborImage(User user, Long harborImageId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiHarborImage gdaiHarborImage = gdaiHarborImageMapper.selectById(harborImageId);
    if (gdaiHarborImage == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiHarborImage.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiHarborImage.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiHarborImage.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiHarborImage;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
org.springframework.stereotype.Service
java.util.Set
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Resource
private GdaiProjectService gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为thirdPartyAdd的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private RestResult thirdPartyAdd(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.thirdPartyAdd params: [{}]", JSON.toJSONString(gdaiHarborImage));
    try {
        Long projectId = gdaiHarborImage.getProjectId();
        String imageName = gdaiHarborImage.getImageName();
        String newImageName = gdaiHarborImage.getNewImageName();
        String tag = gdaiHarborImage.getTag();
        String startupParameter = gdaiHarborImage.getStartupParameter();
        Long creatorId = gdaiHarborImage.getCreatorId();
        String imagePath = gdaiHarborImage.getImagePath();
        if (projectId == null) {
            return RestResult.genFailResult("项目ID不能为空");
        }
        if (StringUtils.isBlank(imageName)) {
            return RestResult.genFailResult("镜像名称不能为空");
        }
        if (StringUtils.isBlank(tag)) {
            return RestResult.genFailResult("标签不能为空");
        }
        if (StringUtils.isBlank(startupParameter)) {
            return RestResult.genFailResult("镜像启动参数不能为空");
        }
        if (creatorId == null) {
            return RestResult.genFailResult("creatorId不能为空");
        }
        if (StringUtils.isBlank(imagePath)) {
            return RestResult.genFailResult("imagePath不能为空");
        }
        //判断newImageName是否为空，如果不为空表示镜像已通过后台推送至harbor库，无需调接口进行判断，只需在数据库校验是否已存在对应记录，如果存在则无需新增记录
        if (StringUtils.isBlank(newImageName)) {
            //根据镜像名称、版本号调用harbor api查询该名称的镜像是否在harbor仓库存在，存在则报错提醒
            //先检查harbor仓库是否存在指定项目
            //去除项目名称后的斜杠
            String projectName = imagePath.substring(0, imagePath.length() - 1);
            Long imageProjectId = getProjectIdByHarbor(projectName);
            if (imageProjectId == null) {
                //harbor库项目不存在，则创建该项目
                Boolean bo1 = createProjectByHarbor(projectName);
                if (!bo1) {
                    return RestResult.genFailResult("在harbor库创建指定名称项目失败");
                }
            } else {
                //检查该项目下是否存在对应镜像
                Boolean bo2 = checkImageIsExists(imageProjectId, imageName);
                if (bo2) {
                    //检查该项目下是否存在对应镜像版本
                    Boolean bo3 = checkTagIsExists(imagePath, imageName, tag);
                    if (bo3) {
                        return RestResult.genFailResult("该镜像已存在对应版本，请检查。");
                    }
                }
            }
        }
        //根据imageName，tag，imagePath查询数据库是否存在相同记录，存在则无需新增记录
        GdaiHarborImage harborImage = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(imageName, tag, imagePath));
        if (harborImage != null) {
            return RestResult.genSuccessResult("新增成功", harborImage);
        }
        //共享标识:0-不共享,1-共享
        gdaiHarborImage.setShareFlag("0");
        //镜像类型：1-自定义镜像，2-预置镜像
        gdaiHarborImage.setImageType("1");
        //解决字段非空约束,默认赋值为空
        gdaiHarborImage.setDockerfileContent("");
        gdaiHarborImage.setPushMessage("");
        gdaiHarborImage.setModifierId(creatorId);
        if (StringUtils.isBlank(newImageName)) {
            //如果newImageName为空，表示第三方厂商随后在页面进行镜像上传操作，如果不为空表示镜像已经由后端人员上传只需要将harbor地址填写到数据库中
            String tempFile = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new Date()) + "-" + UuidUtils.uuid();
            String imageTempPath = cephUploadPath + "/" + projectId + "/" + creatorId + GdaiConstant.IMAGE_TEMP_DIR + tempFile;
            gdaiHarborImage.setTempDir(imageTempPath);
            gdaiHarborImage.setStatus("--");
        } else {
            //SPS-镜像推送中 SPE-镜像推送完毕 SPF-镜像推送异常
            gdaiHarborImage.setStatus("SPE");
            gdaiHarborImage.setImagePath(imagePath);
        }
        Date date = new Date();
        gdaiHarborImage.setCreateTime(date);
        gdaiHarborImage.setModifyTime(date);
        //第三方厂商接入的算法，默认作为部署镜像使用
        gdaiHarborImage.setImageFunction("3");
        gdaiHarborImageMapper.insert(gdaiHarborImage);
        Long harborImageId = gdaiHarborImage.getHarborImageId();
        gdaiHarborImage.setHarborImageId(harborImageId);
        return RestResult.genSuccessResult("新增成功", gdaiHarborImage);
    } catch (Exception e) {
        log.info("新增异常", e);
        return RestResult.genFailResult("新增异常", e);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.util.UuidUtils
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
/**
 * cephfs挂载目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为thirdPartyUpdate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private RestResult thirdPartyUpdate(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.thirdPartyUpdate params: [{}]", JSON.toJSONString(gdaiHarborImage));
    try {
        Long harborImageId = gdaiHarborImage.getHarborImageId();
        Long projectId = gdaiHarborImage.getProjectId();
        String imageName = gdaiHarborImage.getImageName();
        String tag = gdaiHarborImage.getTag();
        String startupParameter = gdaiHarborImage.getStartupParameter();
        Long creatorId = gdaiHarborImage.getCreatorId();
        String imagePath = gdaiHarborImage.getImagePath();
        if (harborImageId == null) {
            return RestResult.genFailResult("镜像ID不能为空");
        }
        if (projectId == null) {
            return RestResult.genFailResult("项目ID不能为空");
        }
        if (StringUtils.isBlank(imageName)) {
            return RestResult.genFailResult("镜像名称不能为空");
        }
        if (StringUtils.isBlank(tag)) {
            return RestResult.genFailResult("标签不能为空");
        }
        if (StringUtils.isBlank(startupParameter)) {
            return RestResult.genFailResult("镜像启动参数不能为空");
        }
        if (creatorId == null) {
            return RestResult.genFailResult("creatorId不能为空");
        }
        if (StringUtils.isBlank(imagePath)) {
            return RestResult.genFailResult("imagePath不能为空");
        }
        GdaiHarborImage image = gdaiHarborImageMapper.selectById(harborImageId);
        if (image == null) {
            return RestResult.genFailResult("该镜像记录不存在");
        }
        //            //比较传进来的镜像名称和版本号是否和数据库中一致，如果不一致则根据传入的新值去数据库查询是否已存在，如果已存在则提示不能修改
        //            if (!image.getImageName().equals(imageName) || !image.getTag().equals(tag)) {
        //                GdaiHarborImage harborImage = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(imageName, tag, imagePath));
        //                if (harborImage != null) {
        //                    return RestResult.genFailResult("该项目下已存在相同版本镜像");
        //                }
        //            }
        GdaiHarborImage harborImage = new GdaiHarborImage();
        harborImage.setHarborImageId(harborImageId);
        harborImage.setProjectId(projectId);
        harborImage.setImageName(imageName);
        harborImage.setTag(tag);
        harborImage.setStartupParameter(startupParameter);
        harborImage.setModifierId(creatorId);
        harborImage.setModifyTime(new Date());
        harborImage.setImagePath(imagePath);
        gdaiHarborImageMapper.updateById(harborImage);
        return RestResult.genSuccessResult("修改成功", harborImage);
    } catch (Exception e) {
        log.info("修改异常", e);
        return RestResult.genFailResult("修改异常", e);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为thirdPartyDelete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private RestResult thirdPartyDelete(GdaiHarborImage gdaiHarborImage) {
    log.info("GdaiHarborImageServiceImpl.thirdPartyDelete params: [{}]", JSON.toJSONString(gdaiHarborImage));
    Long harborImageId = gdaiHarborImage.getHarborImageId();
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    try {
        //查询该镜像是否已经存在
        GdaiHarborImage harborImage = gdaiHarborImageMapper.selectById(harborImageId);
        if (harborImage == null) {
            //根据harborImageId未查询到该记录则认为删除成功
            return RestResult.genSuccessResult("删除成功");
        }
        String newName = harborImage.getNewImageName();
        log.info("newImageName: [{}]", newName);
        if (StringUtils.isNotBlank(newName)) {
            String imageName = harborImage.getImageName();
            String orgTag = harborImage.getTag();
            String imagePath = harborImage.getImagePath();
            Long projectId = harborImage.getProjectId();
            // 解析新镜像名
            // 使用正则表达式匹配
            Pattern pattern = Pattern.compile("^(?:[^:/]+:)?([^/]+)/(.+?)(?::([^/]+))?$");
            Matcher matcher = pattern.matcher(newName);
            if (matcher.matches()) {
                // 检查是否有其他项目在使用该镜像
                List<GdaiHarborImage> gdaiHarborImages = gdaiHarborImageMapper.selectList(new EntityWrapper<GdaiHarborImage>().eq("image_name", imageName).eq("tag", orgTag).eq("image_path", imagePath).ne("project_id", projectId));
                if (gdaiHarborImages.isEmpty()) {
                    //判断harbor库镜像是否存在
                    //检查该项目下是否存在对应镜像版本
                    Boolean bo = checkTagIsExists(imagePath, imageName, orgTag);
                    if (bo) {
                        // 如果没有其他项目使用，则调用API删除镜像
                        String path = imagePath + imageName;
                        String url = String.format(deleteByTagUrl, path, orgTag);
                        String result = httpRequest(url, HttpMethod.DELETE, null);
                        if (HttpStatus.SC_OK == Integer.parseInt(result)) {
                            // 如果API调用成功，则删除本地记录
                            gdaiHarborImageMapper.deleteById(harborImageId);
                        } else {
                            // 记录删除失败的信息
                            log.info("从harbor库删除镜像失败. 返回信息: [{}]", result);
                        }
                    } else {
                        log.info("该镜像harbor库不存在，删除本项目下数据库记录");
                        gdaiHarborImageMapper.deleteById(harborImageId);
                    }
                } else {
                    // 如果有其他项目使用，执行删除操作，记录日志
                    log.info("镜像有其他项目在用，只删除本项目下镜像记录，不删除harbor库镜像");
                    gdaiHarborImageMapper.deleteById(harborImageId);
                }
            } else {
                log.info("镜像名称正则校验不通过，直接删除: [{}]", newName);
                gdaiHarborImageMapper.deleteById(harborImageId);
            }
        } else {
            log.info("镜像名称为空，直接删除");
            gdaiHarborImageMapper.deleteById(harborImageId);
        }
        return RestResult.genSuccessResult("删除成功");
    } catch (Exception e) {
        log.info("删除异常", e);
        return RestResult.genFailResult("删除异常", e);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.apache.http.HttpStatus
org.springframework.http.HttpMethod
org.springframework.stereotype.Service
java.util.List
java.util.regex.Matcher
java.util.regex.Pattern
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
/**
 * Harbor库根据tag删除镜像API
 */
@Value("${harbor-api.deleteByTagUrl}")
private String deleteByTagUrl;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为getProjectIdByHarbor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据harbor镜像名称查询项目id
     *
     * @param projectName
     * @return
     */
private Long getProjectIdByHarbor(String projectName) throws TrainginCenterException {
    log.info("GdaiHarborImageServiceImpl.getProjectIdByHarbor params: [{}]", projectName);
    Long projectId = null;
    try {
        //调harbor api查询所有project
        String getProjectIdUrl = "https://132.126.207.178:32000/api/projects?name=%s";
        String url = String.format(getProjectIdUrl, projectName);
        String body = httpRequestV2(url, HttpMethod.GET, null);
        if (StringUtils.isNotBlank(body)) {
            JSONArray jsonArray = JSON.parseArray(body);
            JSONObject jsonObject = jsonArray.getJSONObject(0);
            projectId = jsonObject.getLong("project_id");
        }
    } catch (Exception e) {
        log.info("查询harbor仓库是否存在该项目异常", e);
        throw new TrainginCenterException(e.getMessage());
    }
    return projectId;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
org.apache.commons.lang3.StringUtils
org.springframework.http.HttpMethod
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为checkImageIsExists的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 检查镜像是否存在
     *
     * @param projectId
     * @param imageName
     * @return
     */
private Boolean checkImageIsExists(Long projectId, String imageName) throws TrainginCenterException {
    log.info("GdaiHarborImageServiceImpl.checkImageIsExists params: [{}],[{}]", projectId, imageName);
    //projectId，该projectId是镜像对应的项目ID（不是AI平台分配项目的ID）
    try {
        //调harbor api检查该镜像是否存在
        String getImageUrl = "https://132.126.207.178:32000/api/repositories?project_id=%s&q=%s";
        String url1 = String.format(getImageUrl, projectId, imageName);
        String body = httpRequestV2(url1, HttpMethod.GET, null);
        if (StringUtils.isNotBlank(body)) {
            return true;
        }
    } catch (Exception e) {
        log.info("检查镜像是否存在异常", e);
        throw new TrainginCenterException(e.getMessage());
    }
    return false;
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
org.apache.commons.lang3.StringUtils
org.springframework.http.HttpMethod
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为checkTagIsExists的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private Boolean checkTagIsExists(String imagePath, String imageName, String tag) throws TrainginCenterException {
    log.info("GdaiHarborImageServiceImpl.checkImageIsExists params: [{}],[{}]", imageName, tag);
    try {
        //镜像存在，调harbor api检查该名称镜像下是否存在对应版本
        String getImageTagUrl = "https://132.126.207.178:32000/api/repositories/%s/tags/%s";
        String path = imagePath + imageName;
        String url2 = String.format(getImageTagUrl, path, tag);
        String resultCode = httpRequest(url2, HttpMethod.GET, null);
        if ("200".equals(resultCode)) {
            return true;
        } else if ("404".equals(resultCode)) {
            return false;
        } else {
            throw new TrainginCenterException("检查镜像版本异常");
        }
    } catch (Exception e) {
        log.info("检查镜像版本异常", e);
        throw new TrainginCenterException(e.getMessage());
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
org.springframework.http.HttpMethod
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiHarborImageServiceImpl中有一个名为createProjectByHarbor的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据harbor项目名称创建项目
     *
     * @param projectName
     * @return
     */
private Boolean createProjectByHarbor(String projectName) {
    log.info("GdaiHarborImageServiceImpl.createProjectByHarbor params: [{}]", projectName);
    try {
        //调harbor api创建项目
        String createProjectIdUrl = "https://132.126.207.178:32000/api/projects";
        JSONObject jsonObject = new JSONObject();
        JSONObject metadataJson = new JSONObject();
        metadataJson.put("public", "false");
        metadataJson.put("enable_content_trust", "false");
        metadataJson.put("auto_scan", "true");
        jsonObject.put("project_name", projectName);
        jsonObject.put("metadata", metadataJson);
        String resultCode = httpRequest(createProjectIdUrl, HttpMethod.POST, jsonObject.toJSONString());
        if ("201".equals(resultCode)) {
            return true;
        }
    } catch (Exception e) {
        log.info("创建harbor项目异常", e);
    }
    return false;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
org.springframework.http.HttpMethod
org.springframework.stereotype.Service
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiIntelligentAnnotation gdaiIntelligentAnnotation) {
    log.info("GdaiIntelligentAnnotationServiceImpl.add params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotation));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
    String datasetName = gdaiIntelligentAnnotation.getDatasetName();
    String dataType = gdaiIntelligentAnnotation.getDataType();
    String annotationType = gdaiIntelligentAnnotation.getAnnotationType();
    String intelligentAnnotationType = gdaiIntelligentAnnotation.getIntelligentAnnotationType();
    String datasetCephPath = gdaiIntelligentAnnotation.getDatasetCephPath();
    Long hardFilterNum = gdaiIntelligentAnnotation.getHardFilterNum();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (StringUtils.isBlank(datasetName)) {
        return RestResult.genFailResult("数据集名称不能为空");
    }
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    if (StringUtils.isBlank(annotationType)) {
        return RestResult.genFailResult("数据集标注类型不能为空");
    }
    if (StringUtils.isBlank(intelligentAnnotationType)) {
        return RestResult.genFailResult("智能标注类型不能为空");
    }
    if (StringUtils.isBlank(datasetCephPath)) {
        return RestResult.genFailResult("数据集存储路径不能为空");
    }
    if (hardFilterNum == null) {
        return RestResult.genFailResult("难例筛选次数不能为空");
    }
    //处于智能标注中的数据集不允许继续创建智能标注任务
    List<GdaiIntelligentAnnotation> annotationList = gdaiIntelligentAnnotationMapper.selectList(new EntityWrapper<GdaiIntelligentAnnotation>().eq("dataset_id", datasetId).eq("status", "S0R"));
    if (annotationList != null && annotationList.size() > 0) {
        return RestResult.genFailResult("该数据集已处于智能标注中");
    }
    //根据不同类型数据集调用不同智能标注校验方法：标注类型：imgcls 图像分类，objdet 物体检测，segment 图像分割，txtcls 文本分类-单标签，txtclsm 文本分类-多标签，txtEntity 文本实体识别
    if ("imgcls".equals(annotationType)) {
        RestResult restResult = imgclsCheckData(datasetId);
        if (restResult != null && "500".equals(restResult.getCode())) {
            return RestResult.genFailResult(restResult.getMessage());
        }
    } else if ("objdet".equals(annotationType)) {
    } else if ("segment".equals(annotationType)) {
    } else if ("txtcls".equals(annotationType)) {
    } else if ("txtclsm".equals(annotationType)) {
    } else if ("txtEntity".equals(annotationType)) {
        RestResult restResult = txtEntityCheckData(datasetId);
        if (restResult != null && "500".equals(restResult.getCode())) {
            return RestResult.genFailResult(restResult.getMessage());
        }
    } else {
        return RestResult.genFailResult("数据集标注类型错误");
    }
    try {
        //启动智能标注时，锁定数据集状态为：S0R-标注中，智能标注结束数据集状态改回为：S0E-标注完成
        gdaiDatasetMapper.updateById(new GdaiDataset(datasetId, "S0R", new Date()));
        //data_type，annotation_type，creator_id查询当前最大版本号，若没有则默认版本为1，如果有则自增1
        int maxVersion = gdaiIntelligentAnnotationMapper.getMaxVersion(dataType, annotationType, userId);
        gdaiIntelligentAnnotation.setIntelligentAnnotationVersion((long) (maxVersion + 1));
        Date curDate = new Date();
        //智能标注状态：S0R-运行中，S0T-已中止，S0E-已完成，S0F-异常终止
        gdaiIntelligentAnnotation.setStatus("S0R");
        //难例筛选状态：1-难例筛选，2-难例确认，3-效果确认，4-下一轮筛选，5-自动标注未标数据
        gdaiIntelligentAnnotation.setHardFilterStatus("1");
        gdaiIntelligentAnnotation.setCreatorId(userId);
        gdaiIntelligentAnnotation.setCreateTime(curDate);
        gdaiIntelligentAnnotation.setModifyTime(curDate);
        gdaiIntelligentAnnotationMapper.insert(gdaiIntelligentAnnotation);
        gdaiIntelligentAnnotation.setIntelligentAnnotationId(gdaiIntelligentAnnotation.getIntelligentAnnotationId());
        //根据不同类型数据集调用不同智能标注方法：标注类型：imgcls 图像分类，objdet 物体检测，segment 图像分割，txtcls 文本分类-单标签，txtclsm 文本分类-多标签，txtEntity 文本实体识别
        if ("imgcls".equals(annotationType)) {
            GdaiTrainingModel imageClassificationJob = createImageClassificationJob(gdaiIntelligentAnnotation, userId);
            System.out.println(imageClassificationJob);
        } else if ("objdet".equals(annotationType)) {
        } else if ("segment".equals(annotationType)) {
        } else if ("txtcls".equals(annotationType)) {
        } else if ("txtclsm".equals(annotationType)) {
        } else if ("txtEntity".equals(annotationType)) {
            GdaiTrainingModel imageClassificationJob = createTxtEntityJob(gdaiIntelligentAnnotation, userId);
            System.out.println(imageClassificationJob);
        } else {
            return RestResult.genFailResult("数据集标注类型错误");
        }
    } catch (Exception e) {
        log.info("新增智能标注异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiIntelligentAnnotation gdaiIntelligentAnnotation) {
    log.info("GdaiIntelligentAnnotationServiceImpl.update params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotation));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    GdaiIntelligentAnnotation intelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
    if (intelligentAnnotation == null) {
        return RestResult.genFailResult("该记录不存在");
    }
    gdaiIntelligentAnnotation.setModifierId(userId);
    gdaiIntelligentAnnotation.setModifyTime(new Date());
    gdaiIntelligentAnnotationMapper.updateById(gdaiIntelligentAnnotation);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为queryList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryList(GdaiIntelligentAnnotationVo gdaiIntelligentAnnotationVo) {
    log.info("GdaiIntelligentAnnotationServiceImpl.queryList params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotationVo));
    String dataType = gdaiIntelligentAnnotationVo.getDataType();
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    Long projectId = gdaiIntelligentAnnotationVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    List<GdaiIntelligentAnnotationVo> list = new ArrayList<>();
    Page<GdaiIntelligentAnnotation> gdaiIntelligentAnnotationPage;
    try {
        Wrapper<GdaiIntelligentAnnotation> ew = new EntityWrapper<GdaiIntelligentAnnotation>().eq("data_type", dataType).eq("project_id", projectId);
        boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
        if (!aiGroupAdminRole) {
            ew.eq("creator_id", userId);
        }
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        ew.orderDesc(desc);
        GdaiIntelligentAnnotationVo intelligentAnnotationVo;
        gdaiIntelligentAnnotationPage = gdaiIntelligentAnnotationService.selectPage(new Page<>(gdaiIntelligentAnnotationVo.getPageNumber(), gdaiIntelligentAnnotationVo.getPageCount()), ew);
        if (gdaiIntelligentAnnotationPage != null && gdaiIntelligentAnnotationPage.getRecords().size() > 0) {
            List<GdaiIntelligentAnnotation> records = gdaiIntelligentAnnotationPage.getRecords();
            for (GdaiIntelligentAnnotation gdaiIntelligentAnnotation : records) {
                intelligentAnnotationVo = new GdaiIntelligentAnnotationVo();
                BeanUtils.copyProperties(gdaiIntelligentAnnotation, intelligentAnnotationVo);
                Long creatorId = gdaiIntelligentAnnotation.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    intelligentAnnotationVo.setCreatorName(userInfo.getUsername());
                }
                list.add(intelligentAnnotationVo);
            }
        }
    } catch (Exception e) {
        log.info("查询智能标注信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    UiPage<GdaiIntelligentAnnotationVo> uiPage = new UiPage<>();
    uiPage.setTotal(gdaiIntelligentAnnotationPage.getTotal());
    uiPage.setPageSize(gdaiIntelligentAnnotationPage.getSize());
    uiPage.setPages(gdaiIntelligentAnnotationPage.getPages());
    uiPage.setPageNum(gdaiIntelligentAnnotationPage.getCurrent());
    uiPage.setList(list);
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
com.eshore.gdai.trainingcenter.vo.GdaiIntelligentAnnotationVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationService gdaiIntelligentAnnotationService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为queryById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryById(GdaiIntelligentAnnotation gdaiIntelligentAnnotation) {
    log.info("GdaiIntelligentAnnotationServiceImpl.queryById params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotation));
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("智能标注ID不能为空");
    }
    GdaiIntelligentAnnotation intelligentAnnotation;
    try {
        intelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
        if (intelligentAnnotation == null) {
            return RestResult.genFailResult("未查询到该记录");
        }
    } catch (Exception e) {
        log.info("查询异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(intelligentAnnotation);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiIntelligentAnnotationVo gdaiIntelligentAnnotationVo) {
    log.info("GdaiIntelligentAnnotationServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotationVo));
    Long intelligentAnnotationId = gdaiIntelligentAnnotationVo.getIntelligentAnnotationId();
    String isSave = gdaiIntelligentAnnotationVo.getIsSave();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("智能标注ID不能为空");
    }
    if (StringUtils.isBlank(isSave)) {
        return RestResult.genFailResult("保存标志不能为空");
    }
    try {
        //删除之前检查是否存在
        GdaiIntelligentAnnotation intelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
        if (intelligentAnnotation == null) {
            return RestResult.genFailResult("该记录不存在");
        }
        Long datasetId = intelligentAnnotation.getDatasetId();
        //关联删除训练记录
        List<GdaiIntelligentAnnotationTraining> list = gdaiIntelligentAnnotationTrainingMapper.selectList(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("intelligent_annotation_id", intelligentAnnotationId));
        if (list != null && list.size() > 0) {
            for (GdaiIntelligentAnnotationTraining annotationTraining : list) {
                Long trainId = annotationTraining.getTrainId();
                GdaiTrainingModel trainingModel = gdaiTrainingModelMapper.selectById(trainId);
                if (trainingModel != null) {
                    String jobName = trainingModel.getJobName();
                    String podName = trainingModel.getPodName();
                    String nameSpace = trainingModel.getNameSpace();
                    if (StringUtils.isNotBlank(jobName) && StringUtils.isNotBlank(nameSpace)) {
                        //删除job
                        ApiClient client = k8sInit2.getConnection();
                        BatchV1Api appsInstance = new BatchV1Api(client);
                        V1JobList v1JobList = appsInstance.listNamespacedJob(nameSpace, null, null, null, null, null, null, null, null, null, null);
                        List<V1Job> items = v1JobList.getItems();
                        for (V1Job v1Job : items) {
                            String name = v1Job.getMetadata().getName();
                            if (jobName.equals(name)) {
                                appsInstance.deleteNamespacedJob(jobName, nameSpace, null, null, 0, null, "", new V1DeleteOptions());
                                break;
                            }
                        }
                    }
                    if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(nameSpace)) {
                        //删除pod
                        ApiClient client = k8sInit2.getConnection();
                        CoreV1Api api = new CoreV1Api(client);
                        V1PodList v1PodList = api.listNamespacedPod(nameSpace, null, null, null, null, null, null, null, null, null, null);
                        List<V1Pod> items = v1PodList.getItems();
                        for (V1Pod v1Pod : items) {
                            String name = v1Pod.getMetadata().getName();
                            if (podName.equals(name)) {
                                api.deleteNamespacedPod(podName, nameSpace, null, null, 0, null, "", new V1DeleteOptions());
                                break;
                            }
                        }
                    }
                    //删除训练记录
                    gdaiTrainingModelMapper.deleteById(trainId);
                    //删除关系表记录
                    gdaiIntelligentAnnotationTrainingMapper.delete(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("intelligent_annotation_id", intelligentAnnotationId).eq("train_id", trainId));
                }
            }
        }
        //删除的同时，删除模型保存的路径
        String datasetCephPath = intelligentAnnotation.getDatasetCephPath();
        String modelOutPath = datasetCephPath + "/modelOut";
        FileUtil.deleteFile(FileUtils.getFile(modelOutPath));
        //isSave为0表示不保存已确认的标注数据（删除待确认数据）
        if ("0".equals(isSave)) {
            List<GdaiDatafile> gdaiDatafileList = new ArrayList<>();
            GdaiDatafile gdaiDatafile;
            List<GdaiDatafileLabel> datafileLabelList = new ArrayList<>();
            GdaiDatafileLabel gdaiDatafileLabel;
            //根据数据集ID和待确认状态(待确认状态值:1-已确认,0-未确认)查询出待确认数据
            List<GdaiDatafile> datafileList = gdaiDatafileMapper.selectList(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("confirm_status", 0));
            Date date = new Date();
            if (datafileList != null && datafileList.size() > 0) {
                for (GdaiDatafile dataFile : datafileList) {
                    //批量修改待确认状态使用
                    gdaiDatafile = new GdaiDatafile();
                    gdaiDatafile.setMarkStatus("1");
                    gdaiDatafile.setConfirmStatus("1");
                    gdaiDatafile.setDatafileId(dataFile.getDatafileId());
                    gdaiDatafile.setModifyTime(date);
                    gdaiDatafileList.add(gdaiDatafile);
                    //批量删除待确认数据坐标使用
                    gdaiDatafileLabel = new GdaiDatafileLabel();
                    gdaiDatafileLabel.setDatasetId(dataFile.getDatasetId());
                    gdaiDatafileLabel.setDatafileId(dataFile.getDatafileId());
                    datafileLabelList.add(gdaiDatafileLabel);
                }
                //先将待确认的文件状态改为1-已确认
                gdaiDatafileMapper.updateBatch(gdaiDatafileList);
                //删除该文件对应的坐标信息
                gdaiDatafileLabelMapper.deleteBatch(datafileLabelList);
            }
        }
        //isSave为1表示保存已确认的标注数据（将待确认数据改为已标注）
        if ("1".equals(isSave)) {
            List<GdaiDatafile> gdaiDatafileList = new ArrayList<>();
            GdaiDatafile gdaiDatafile;
            //根据数据集ID和待确认状态(待确认状态值:1-已确认,0-未确认)查询出待确认数据
            List<GdaiDatafile> datafileList = gdaiDatafileMapper.selectList(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("confirm_status", 0));
            Date date = new Date();
            if (datafileList != null && datafileList.size() > 0) {
                for (GdaiDatafile dataFile : datafileList) {
                    //批量修改待确认状态使用
                    gdaiDatafile = new GdaiDatafile();
                    gdaiDatafile.setMarkStatus("2");
                    gdaiDatafile.setConfirmStatus("1");
                    gdaiDatafile.setDatafileId(dataFile.getDatafileId());
                    gdaiDatafile.setModifyTime(date);
                    gdaiDatafileList.add(gdaiDatafile);
                }
                //先将待确认的文件状态改为1-已确认
                gdaiDatafileMapper.updateBatch(gdaiDatafileList);
            }
        }
        //自动标注未标文件结束，数据集状态改回为：标注状态:S0N-未标注
        gdaiDatasetMapper.updateById(new GdaiDataset(datasetId, "S0N", new Date()));
        gdaiIntelligentAnnotationMapper.deleteById(intelligentAnnotationId);
        return RestResult.genSuccessResult("删除成功");
    } catch (Exception e) {
        log.info("删除记录异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return RestResult.genFailResult("删除异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为stopAnnotationJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult stopAnnotationJob(GdaiIntelligentAnnotationVo gdaiIntelligentAnnotationVo) {
    log.info("GdaiIntelligentAnnotationServiceImpl.stopAnnotationJob params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotationVo));
    Long intelligentAnnotationId = gdaiIntelligentAnnotationVo.getIntelligentAnnotationId();
    String isSave = gdaiIntelligentAnnotationVo.getIsSave();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    if (StringUtils.isBlank(isSave)) {
        return RestResult.genFailResult("保存标志不能为空");
    }
    GdaiIntelligentAnnotation gdaiIntelligentAnnotation;
    try {
        //根据任务ID查询该任务是否存在
        gdaiIntelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
        if (gdaiIntelligentAnnotation == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
        //关联删除训练记录
        List<GdaiIntelligentAnnotationTraining> list = gdaiIntelligentAnnotationTrainingMapper.selectList(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("intelligent_annotation_id", intelligentAnnotationId));
        if (list != null && list.size() > 0) {
            for (GdaiIntelligentAnnotationTraining annotationTraining : list) {
                Long trainId = annotationTraining.getTrainId();
                GdaiTrainingModel trainingModel = gdaiTrainingModelMapper.selectById(trainId);
                if (trainingModel != null) {
                    String jobName = trainingModel.getJobName();
                    String podName = trainingModel.getPodName();
                    String nameSpace = trainingModel.getNameSpace();
                    if (StringUtils.isNotBlank(jobName) && StringUtils.isNotBlank(nameSpace)) {
                        //删除job
                        ApiClient client = k8sInit2.getConnection();
                        BatchV1Api appsInstance = new BatchV1Api(client);
                        V1JobList v1JobList = appsInstance.listNamespacedJob(nameSpace, null, null, null, null, null, null, null, null, null, null);
                        List<V1Job> items = v1JobList.getItems();
                        for (V1Job v1Job : items) {
                            String name = v1Job.getMetadata().getName();
                            if (jobName.equals(name)) {
                                appsInstance.deleteNamespacedJob(jobName, nameSpace, null, null, 0, null, "", new V1DeleteOptions());
                                break;
                            }
                        }
                    }
                    if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(nameSpace)) {
                        //删除pod
                        ApiClient client = k8sInit2.getConnection();
                        CoreV1Api api = new CoreV1Api(client);
                        V1PodList v1PodList = api.listNamespacedPod(nameSpace, null, null, null, null, null, null, null, null, null, null);
                        List<V1Pod> items = v1PodList.getItems();
                        for (V1Pod v1Pod : items) {
                            String name = v1Pod.getMetadata().getName();
                            if (podName.equals(name)) {
                                api.deleteNamespacedPod(podName, nameSpace, null, null, 0, null, "", new V1DeleteOptions());
                                break;
                            }
                        }
                    }
                    //删除训练记录
                    gdaiTrainingModelMapper.deleteById(trainId);
                    //删除关系表记录
                    gdaiIntelligentAnnotationTrainingMapper.delete(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("intelligent_annotation_id", intelligentAnnotationId).eq("train_id", trainId));
                }
            }
        }
        //删除的同时，删除模型保存的路径
        String datasetCephPath = gdaiIntelligentAnnotation.getDatasetCephPath();
        String modelOutPath = datasetCephPath + "/modelOut";
        FileUtil.deleteFile(FileUtils.getFile(modelOutPath));
        //isSave为0表示不保存已确认的标注数据（删除待确认数据）
        if ("0".equals(isSave)) {
            List<GdaiDatafile> gdaiDatafileList = new ArrayList<>();
            GdaiDatafile gdaiDatafile;
            List<GdaiDatafileLabel> datafileLabelList = new ArrayList<>();
            GdaiDatafileLabel gdaiDatafileLabel;
            //根据数据集ID和待确认状态(待确认状态值:1-已确认,0-未确认)查询出待确认数据
            List<GdaiDatafile> datafileList = gdaiDatafileMapper.selectList(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("confirm_status", 0));
            Date date = new Date();
            if (datafileList != null && datafileList.size() > 0) {
                for (GdaiDatafile dataFile : datafileList) {
                    //批量修改待确认状态使用
                    gdaiDatafile = new GdaiDatafile();
                    gdaiDatafile.setMarkStatus("1");
                    gdaiDatafile.setConfirmStatus("1");
                    gdaiDatafile.setDatafileId(dataFile.getDatafileId());
                    gdaiDatafile.setModifyTime(date);
                    gdaiDatafileList.add(gdaiDatafile);
                    //批量删除待确认数据坐标使用
                    gdaiDatafileLabel = new GdaiDatafileLabel();
                    gdaiDatafileLabel.setDatasetId(dataFile.getDatasetId());
                    gdaiDatafileLabel.setDatafileId(dataFile.getDatafileId());
                    datafileLabelList.add(gdaiDatafileLabel);
                }
                //先将待确认的文件状态改为1-已确认
                gdaiDatafileMapper.updateBatch(gdaiDatafileList);
                //删除该文件对应的坐标信息
                gdaiDatafileLabelMapper.deleteBatch(datafileLabelList);
            }
        }
        //isSave为1表示保存已确认的标注数据（将待确认数据改为已标注）
        if ("1".equals(isSave)) {
            List<GdaiDatafile> gdaiDatafileList = new ArrayList<>();
            GdaiDatafile gdaiDatafile;
            //根据数据集ID和待确认状态(待确认状态值:1-已确认,0-未确认)查询出待确认数据
            List<GdaiDatafile> datafileList = gdaiDatafileMapper.selectList(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("confirm_status", 0));
            Date date = new Date();
            if (datafileList != null && datafileList.size() > 0) {
                for (GdaiDatafile dataFile : datafileList) {
                    //批量修改待确认状态使用
                    gdaiDatafile = new GdaiDatafile();
                    gdaiDatafile.setMarkStatus("2");
                    gdaiDatafile.setConfirmStatus("1");
                    gdaiDatafile.setDatafileId(dataFile.getDatafileId());
                    gdaiDatafile.setModifyTime(date);
                    gdaiDatafileList.add(gdaiDatafile);
                }
                //先将待确认的文件状态改为1-已确认
                gdaiDatafileMapper.updateBatch(gdaiDatafileList);
            }
        }
        //任务终止更新智能标注状态为：S0T-已中止，难例筛选状态：难例筛选状态：1-难例筛选
        gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "S0T", "1", new Date()));
        //任务终止，数据集状态改回为：标注状态:S0N-未标注
        gdaiDatasetMapper.updateById(new GdaiDataset(datasetId, "S0N", new Date()));
    } catch (Exception e) {
        log.info("终止任务异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("终止任务异常");
    }
    return RestResult.genSuccessResult("终止任务成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为deleteModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteModel(GdaiIntelligentAnnotation gdaiIntelligentAnnotation) {
    log.info("GdaiIntelligentAnnotationServiceImpl.deleteModel params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotation));
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("智能标注ID不能为空");
    }
    try {
        //删除之前检查是否存在
        GdaiIntelligentAnnotation intelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
        if (intelligentAnnotation == null) {
            return RestResult.genFailResult("该记录不存在");
        }
        //删除模型保存的路径（每次触发下一次难例筛选的时候删除上次生成的模型，直到最后一次难例筛选完模型不删除）
        String datasetCephPath = intelligentAnnotation.getDatasetCephPath();
        String modelOutPath = datasetCephPath + "/modelOut";
        FileUtil.deleteFile(FileUtils.getFile(modelOutPath));
    } catch (Exception e) {
        log.info("删除异常", e);
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
org.apache.commons.io.FileUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为autoMarkFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult autoMarkFile(GdaiIntelligentAnnotation gdaiIntelligentAnnotation) {
    log.info("GdaiIntelligentAnnotationServiceImpl.autoMarkFile params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotation));
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    try {
        //根据任务ID查询该任务是否存在
        gdaiIntelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
        if (gdaiIntelligentAnnotation == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
        String csvFilePath = "/datasets/csv/nanli.csv";
        String confirmStatus = "1";
        RestResult restResult = gdaiDatafileLabelServiceImpl.addBatchFromCsvFile(datasetId, confirmStatus, csvFilePath, 0f);
        if (restResult != null) {
            String code = restResult.getCode();
            if ("200".equals(code)) {
                log.info("csv文件入库成功");
                //更新智能标注status状态为：S0E-已完成，hard_filter_status状态为：5-自动标注未标数据
                gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "S0E", "5", new Date()));
                //自动标注未标文件结束，数据集状态改回为：S0E-标注完成
                gdaiDatasetMapper.updateById(new GdaiDataset(datasetId, "S0E", new Date()));
            } else {
                log.info("csv文件入库失败", restResult.getMessage());
                GdaiIntelligentAnnotation intelligentAnnotation = new GdaiIntelligentAnnotation();
                intelligentAnnotation.setIntelligentAnnotationId(intelligentAnnotationId);
                intelligentAnnotation.setStatus("S0F");
                intelligentAnnotation.setModifyTime(new Date());
                gdaiIntelligentAnnotationMapper.updateById(intelligentAnnotation);
                return RestResult.genFailResult("自动标注未标文件失败");
            }
        }
    } catch (Exception e) {
        log.info("自动标注未标文件异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("自动标注未标文件异常");
    }
    return RestResult.genSuccessResult("自动标注未标文件成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatafileLabelServiceImpl gdaiDatafileLabelServiceImpl;
@Resource
private GdaiDatafileLabelService gdaiDatafileLabelService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为nextHardFilter的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult nextHardFilter(GdaiIntelligentAnnotation gdaiIntelligentAnnotation) {
    log.info("GdaiIntelligentAnnotationServiceImpl.nextHardFilter params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotation));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    Long hardFilterNum = gdaiIntelligentAnnotation.getHardFilterNum();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    if (hardFilterNum == null) {
        return RestResult.genFailResult("难例筛选次数不能为空");
    }
    try {
        //根据任务ID查询该任务是否存在
        GdaiIntelligentAnnotation intelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
        if (intelligentAnnotation == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        //删除模型保存的路径（每次触发下一次难例筛选的时候删除上次生成的模型，直到最后一次难例筛选完模型不删除）
        String datasetCephPath = intelligentAnnotation.getDatasetCephPath();
        String modelOutPath = datasetCephPath + "/modelOut";
        FileUtil.deleteFile(FileUtils.getFile(modelOutPath));
        String annotationType = intelligentAnnotation.getAnnotationType();
        //下一轮难例筛选开始前更新难例状态及难例筛选次数
        intelligentAnnotation.setHardFilterNum(hardFilterNum);
        intelligentAnnotation.setHardFilterStatus("1");
        intelligentAnnotation.setModifyTime(new Date());
        gdaiIntelligentAnnotationMapper.updateById(intelligentAnnotation);
        //根据不同类型数据集调用不同智能标注方法：标注类型：imgcls 图像分类，objdet 物体检测，segment 图像分割，txtcls 文本分类-单标签，txtclsm 文本分类-多标签，txtEntity 文本实体识别
        if ("imgcls".equals(annotationType)) {
            GdaiTrainingModel imageClassificationJob = createImageClassificationJob(intelligentAnnotation, userId);
            System.out.println(imageClassificationJob);
        } else if ("objdet".equals(annotationType)) {
        } else if ("segment".equals(annotationType)) {
        } else if ("txtcls".equals(annotationType)) {
        } else if ("txtclsm".equals(annotationType)) {
        } else if ("txtEntity".equals(annotationType)) {
            GdaiTrainingModel imageClassificationJob = createTxtEntityJob(intelligentAnnotation, userId);
            System.out.println(imageClassificationJob);
        } else {
            return RestResult.genFailResult("数据集标注类型错误");
        }
    } catch (Exception e) {
        log.info("下一轮难例筛选异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("下一轮难例筛选异常");
    }
    return RestResult.genSuccessResult("下一轮难例筛选成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
org.apache.commons.io.FileUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为restartJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult restartJob(GdaiIntelligentAnnotation gdaiIntelligentAnnotation) {
    log.info("GdaiIntelligentAnnotationServiceImpl.restartJob params: [{}]", JSON.toJSONString(gdaiIntelligentAnnotation));
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    if (intelligentAnnotationId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    try {
        //根据任务ID查询该任务是否存在
        GdaiIntelligentAnnotation intelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(intelligentAnnotationId);
        if (intelligentAnnotation == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        Long datasetId = intelligentAnnotation.getDatasetId();
        //处于智能标注中的数据集不允许继续创建智能标注任务
        List<GdaiIntelligentAnnotation> annotationList = gdaiIntelligentAnnotationMapper.selectList(new EntityWrapper<GdaiIntelligentAnnotation>().eq("dataset_id", datasetId).eq("status", "S0R"));
        if (annotationList != null && annotationList.size() > 0) {
            return RestResult.genFailResult("该数据集已处于智能标注中");
        }
        String annotationType = intelligentAnnotation.getAnnotationType();
        //根据不同类型数据集调用不同智能标注校验方法：标注类型：imgcls 图像分类，objdet 物体检测，segment 图像分割，txtcls 文本分类-单标签，txtclsm 文本分类-多标签，txtEntity 文本实体识别
        if ("imgcls".equals(annotationType)) {
            RestResult restResult = imgclsCheckData(datasetId);
            if (restResult != null && "500".equals(restResult.getCode())) {
                return RestResult.genFailResult(restResult.getMessage());
            }
        } else if ("objdet".equals(annotationType)) {
        } else if ("segment".equals(annotationType)) {
        } else if ("txtcls".equals(annotationType)) {
        } else if ("txtclsm".equals(annotationType)) {
        } else if ("txtEntity".equals(annotationType)) {
            RestResult restResult = txtEntityCheckData(datasetId);
            if (restResult != null && "500".equals(restResult.getCode())) {
                return RestResult.genFailResult(restResult.getMessage());
            }
        } else {
            return RestResult.genFailResult("数据集标注类型错误");
        }
        //启动智能标注时，锁定数据集状态为：S0R-标注中
        gdaiDatasetMapper.updateById(new GdaiDataset(datasetId, "S0R", new Date()));
        //重启任务更新智能标注状态为：S0R-运行中，难例筛选状态：难例筛选状态：1-难例筛选
        gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "S0R", 1L, "1", new Date()));
        //重启任务之前删除已存在的模型
        String datasetCephPath = intelligentAnnotation.getDatasetCephPath();
        String modelOutPath = datasetCephPath + "/modelOut";
        FileUtil.deleteFile(FileUtils.getFile(modelOutPath));
        //根据不同类型数据集调用不同智能标注方法：标注类型：imgcls 图像分类，objdet 物体检测，segment 图像分割，txtcls 文本分类-单标签，txtclsm 文本分类-多标签，txtEntity 文本实体识别
        if ("imgcls".equals(annotationType)) {
            GdaiTrainingModel imageClassificationJob = createImageClassificationJob(intelligentAnnotation, userId);
            System.out.println(imageClassificationJob);
        } else if ("objdet".equals(annotationType)) {
        } else if ("segment".equals(annotationType)) {
        } else if ("txtcls".equals(annotationType)) {
        } else if ("txtclsm".equals(annotationType)) {
        } else if ("txtEntity".equals(annotationType)) {
            GdaiTrainingModel imageClassificationJob = createTxtEntityJob(intelligentAnnotation, userId);
            System.out.println(imageClassificationJob);
        } else {
            return RestResult.genFailResult("数据集标注类型错误");
        }
    } catch (Exception e) {
        log.info("重启智能标注异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("重启异常");
    }
    return RestResult.genSuccessResult("重启成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiIntelligentAnnotationService
org.apache.commons.io.FileUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为createImageClassificationJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 创建图像分类智能标注任务
     *
     * @param gdaiIntelligentAnnotation
     * @param userId
     * @return
     */
private GdaiTrainingModel createImageClassificationJob(GdaiIntelligentAnnotation gdaiIntelligentAnnotation, Long userId) throws Exception {
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    String datasetName = gdaiIntelligentAnnotation.getDatasetName();
    String datasetCephPath = gdaiIntelligentAnnotation.getDatasetCephPath();
    Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
    Long projectId = gdaiIntelligentAnnotation.getProjectId();
    //根据数据集ID查询该数据集下有几类标签(该数量决定了启动脚本参数值)
    int labelCount = gdaiDatalabelMapper.queryCountByDatasetId(datasetId);
    //拼装数据集和模型保存路径
    String datasetPath = datasetCephPath + "/datasets";
    String modelOutPath = datasetCephPath + "/modelOut";
    String sourcePath = datasetCephPath + "/source";
    FileUtil.createDir(modelOutPath);
    Long hardFilterNum = gdaiIntelligentAnnotation.getHardFilterNum();
    GdaiTrainingModel gdaiTrainingModel = new GdaiTrainingModel();
    try {
        //1.先往训练表中插入一条记录以便于获取trainId
        Date date = new Date();
        gdaiTrainingModel.setCreatorId(userId);
        gdaiTrainingModel.setCreateTime(date);
        gdaiTrainingModel.setModifierId(userId);
        gdaiTrainingModel.setModifyTime(date);
        //解决字段非空约束,默认赋值为空
        gdaiTrainingModel.setTrainYmlContent("");
        gdaiTrainingModel.setCommandAndArgs("");
        gdaiTrainingModel.setCntrMsg("");
        gdaiTrainingModel.setContext("");
        //智能训练版本号跟着难例筛选次数一致
        gdaiTrainingModel.setTrainVersion(hardFilterNum);
        gdaiTrainingModelMapper.insert(gdaiTrainingModel);
        Long trainId = gdaiTrainingModel.getTrainId();
        gdaiTrainingModel.setTrainId(trainId);
        //2.同时往gdai_intelligent_annotation_training关系表插入一条记录
        gdaiIntelligentAnnotationTrainingMapper.insert(new GdaiIntelligentAnnotationTraining(intelligentAnnotationId, trainId, userId, date, userId, date));
        //3.拼装启动job任务参数
        JobTemplateObject job = new JobTemplateObject();
        job.bizType = "intelligent_annotation_model";
        job.bizId = String.valueOf(trainId);
        job.bizEnv = LabelUtils.getBizEnvLabelStr();
        job.name = "train-job-annotation-" + trainId;
        job.core = 2;
        job.memorySize = "16G";
        job.gpu = new JobTemplateObject.GPU();
        job.gpu.cardNumber = "1";
        job.gpu.computingPower = "50";
        job.gpu.gpuSize = "8000";
        job.image = "harbor.ccse.ctyun.cn:32000/training/automark:v6";
        if (labelCount == 2) {
            job.commandAndArgs = "python /home/automark_predict_images.py --train_path=/datasets/csv/train.csv --test_path=/datasets/csv/test.csv --nanli_path=/datasets/csv/nanli.csv --model_out=/out/modelOut --problem_type=binary";
        }
        if (labelCount >= 3) {
            job.commandAndArgs = "python /home/automark_predict_images.py --train_path=/datasets/csv/train.csv --test_path=/datasets/csv/test.csv --nanli_path=/datasets/csv/nanli.csv --model_out=/out/modelOut --problem_type=multiclass";
        }
        job.volumes = new JobTemplateObject.Volumes[] { new JobTemplateObject.Volumes("volume-0", datasetPath, "/datasets"), new JobTemplateObject.Volumes("volume-1", modelOutPath, "/out"), new JobTemplateObject.Volumes("volume-2", sourcePath, "/source") };
        //set env
        List<JobTemplateObject.Env> envs = new ArrayList<>();
        JobTemplateObject.Env env = new JobTemplateObject.Env();
        env.setName("NVIDIA_DRIVER_CAPABILITIES");
        env.setValue("compute,utility");
        envs.add(env);
        job.setEnvs(envs);
        JSONObject jsonObject = (JSONObject) JSONObject.toJSON(job);
        log.info("JobTemplateObject jsonObject:" + jsonObject);
        gdaiTrainingModel.setProjectId(projectId);
        gdaiTrainingModel.setTrainId(trainId);
        gdaiTrainingModel.setDatasetId(datasetId);
        gdaiTrainingModel.setTrainName(datasetName + "_智能标注");
        gdaiTrainingModel.setShareFlag("0");
        gdaiTrainingModel.setDatasetSource("1");
        gdaiTrainingModel.setModelSavePath(modelOutPath);
        gdaiTrainingModel.setIsCustRes("1");
        gdaiTrainingModel.setComputingPower("50");
        gdaiTrainingModel.setStatus("Pending");
        gdaiTrainingModel.setCardNumber(number);
        gdaiTrainingModel.setProcessUnitType("GPU");
        int core = job.getCore();
        String memorySize = job.getMemorySize();
        JobTemplateObject.GPU gpu = job.getGpu();
        String gpuSize = gpu.getGpuSize();
        gdaiTrainingModel.setCore(String.valueOf(core));
        gdaiTrainingModel.setMemorySize(memorySize);
        gdaiTrainingModel.setGpuSize(gpuSize);
        long size = Long.parseLong(gpuSize) * 1024 * 1024;
        String gpuSizeChange = UnitConvertUtils.getSize(size);
        String environment = core + "核CPU" + memorySize + "内存_" + gpuSizeChange;
        gdaiTrainingModel.setTrainingEnvironment(environment);
        gdaiTrainingModel.setTrainSource("2");
        gdaiTrainingModelMapper.updateById(gdaiTrainingModel);
        //4.创建job启动训练任务
        gdaiTrainingModel = createJob(k8sInit2, k8sClientOperator, gdaiTrainingModel, job);
    } catch (Exception e) {
        log.info("create job 异常", e);
        throw e;
    }
    return gdaiTrainingModel;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
com.eshore.gdai.trainingcenter.util
org.springframework.beans.factory.annotation.Value
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为createTxtEntityJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 创建文本实体抽取智能标注任务
     *
     * @param gdaiIntelligentAnnotation
     * @param userId
     * @return
     */
private GdaiTrainingModel createTxtEntityJob(GdaiIntelligentAnnotation gdaiIntelligentAnnotation, Long userId) throws Exception {
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    String datasetName = gdaiIntelligentAnnotation.getDatasetName();
    String datasetCephPath = gdaiIntelligentAnnotation.getDatasetCephPath();
    Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
    Long projectId = gdaiIntelligentAnnotation.getProjectId();
    //拼装数据集和模型保存路径
    String datasetPath = datasetCephPath + "/datasets";
    String modelOutPath = datasetCephPath + "/modelOut";
    String sourcePath = datasetCephPath + "/source";
    FileUtil.createDir(modelOutPath);
    Long hardFilterNum = gdaiIntelligentAnnotation.getHardFilterNum();
    GdaiTrainingModel gdaiTrainingModel = new GdaiTrainingModel();
    try {
        //1.先往训练表中插入一条记录以便于获取trainId
        Date date = new Date();
        gdaiTrainingModel.setCreatorId(userId);
        gdaiTrainingModel.setCreateTime(date);
        gdaiTrainingModel.setModifierId(userId);
        gdaiTrainingModel.setModifyTime(date);
        //解决字段非空约束,默认赋值为空
        gdaiTrainingModel.setTrainYmlContent("");
        gdaiTrainingModel.setCommandAndArgs("");
        gdaiTrainingModel.setCntrMsg("");
        gdaiTrainingModel.setContext("");
        //智能训练版本号跟着难例筛选次数一致
        gdaiTrainingModel.setTrainVersion(hardFilterNum);
        gdaiTrainingModelMapper.insert(gdaiTrainingModel);
        Long trainId = gdaiTrainingModel.getTrainId();
        gdaiTrainingModel.setTrainId(trainId);
        //2.同时往gdai_intelligent_annotation_training关系表插入一条记录
        gdaiIntelligentAnnotationTrainingMapper.insert(new GdaiIntelligentAnnotationTraining(intelligentAnnotationId, trainId, userId, date, userId, date));
        //3.拼装启动job任务参数
        JobTemplateObject job = new JobTemplateObject();
        job.bizType = "intelligent_annotation_model";
        job.bizId = String.valueOf(trainId);
        job.bizEnv = LabelUtils.getBizEnvLabelStr();
        job.name = "train-job-annotation-" + trainId;
        job.core = 2;
        job.memorySize = "16G";
        job.gpu = new JobTemplateObject.GPU();
        job.gpu.cardNumber = "1";
        job.gpu.computingPower = "50";
        job.gpu.gpuSize = "8000";
        job.image = "harbor.ccse.ctyun.cn:32000/training/automark:v6";
        job.commandAndArgs = "python /home/automark_predict_ner.py --train_path=/datasets/csv/train.csv --test_path=/datasets/csv/test.csv  --result_path=/datasets/csv/nanli.csv --model_out=/out/model_out";
        job.volumes = new JobTemplateObject.Volumes[] { new JobTemplateObject.Volumes("volume-0", datasetPath, "/datasets"), new JobTemplateObject.Volumes("volume-1", modelOutPath, "/out"), new JobTemplateObject.Volumes("volume-2", sourcePath, "/source") };
        //set env
        List<JobTemplateObject.Env> envs = new ArrayList<>();
        JobTemplateObject.Env env = new JobTemplateObject.Env();
        env.setName("NVIDIA_DRIVER_CAPABILITIES");
        env.setValue("compute,utility");
        envs.add(env);
        job.setEnvs(envs);
        JSONObject jsonObject = (JSONObject) JSONObject.toJSON(job);
        log.info("JobTemplateObject jsonObject:" + jsonObject);
        gdaiTrainingModel.setProjectId(projectId);
        gdaiTrainingModel.setTrainId(trainId);
        gdaiTrainingModel.setDatasetId(datasetId);
        gdaiTrainingModel.setTrainName(datasetName + "_智能标注");
        gdaiTrainingModel.setShareFlag("0");
        gdaiTrainingModel.setDatasetSource("1");
        gdaiTrainingModel.setModelSavePath(modelOutPath);
        gdaiTrainingModel.setIsCustRes("1");
        gdaiTrainingModel.setComputingPower("50");
        gdaiTrainingModel.setStatus("Pending");
        gdaiTrainingModel.setCardNumber(number);
        gdaiTrainingModel.setProcessUnitType("GPU");
        int core = job.getCore();
        String memorySize = job.getMemorySize();
        JobTemplateObject.GPU gpu = job.getGpu();
        String gpuSize = gpu.getGpuSize();
        gdaiTrainingModel.setCore(String.valueOf(core));
        gdaiTrainingModel.setMemorySize(memorySize);
        gdaiTrainingModel.setGpuSize(gpuSize);
        long size = Long.parseLong(gpuSize) * 1024 * 1024;
        String gpuSizeChange = UnitConvertUtils.getSize(size);
        String environment = core + "核CPU" + memorySize + "内存_" + gpuSizeChange;
        gdaiTrainingModel.setTrainingEnvironment(environment);
        gdaiTrainingModel.setTrainSource("2");
        gdaiTrainingModelMapper.updateById(gdaiTrainingModel);
        //4.创建job启动训练任务
        gdaiTrainingModel = createJob(k8sInit2, k8sClientOperator, gdaiTrainingModel, job);
    } catch (Exception e) {
        log.info("create job 异常", e);
        throw e;
    }
    return gdaiTrainingModel;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
com.eshore.gdai.trainingcenter.util
org.springframework.beans.factory.annotation.Value
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为createObjdetJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 创建物体检测智能标注任务
     *
     * @param gdaiIntelligentAnnotation
     * @param userId
     * @return
     */
private GdaiTrainingModel createObjdetJob(GdaiIntelligentAnnotation gdaiIntelligentAnnotation, Long userId) throws Exception {
    Long intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
    String datasetName = gdaiIntelligentAnnotation.getDatasetName();
    String datasetCephPath = gdaiIntelligentAnnotation.getDatasetCephPath();
    Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
    Long projectId = gdaiIntelligentAnnotation.getProjectId();
    //拼装数据集和模型保存路径
    String datasetPath = datasetCephPath + "/datasets";
    String modelOutPath = datasetCephPath + "/modelOut";
    String sourcePath = datasetCephPath + "/source";
    FileUtil.createDir(modelOutPath);
    Long hardFilterNum = gdaiIntelligentAnnotation.getHardFilterNum();
    GdaiTrainingModel gdaiTrainingModel = new GdaiTrainingModel();
    try {
        //1.先往训练表中插入一条记录以便于获取trainId
        Date date = new Date();
        gdaiTrainingModel.setCreatorId(userId);
        gdaiTrainingModel.setCreateTime(date);
        gdaiTrainingModel.setModifierId(userId);
        gdaiTrainingModel.setModifyTime(date);
        gdaiTrainingModel.setContext("");
        gdaiTrainingModelMapper.insert(gdaiTrainingModel);
        Long trainId = gdaiTrainingModel.getTrainId();
        gdaiTrainingModel.setTrainId(trainId);
        //2.同时往gdai_intelligent_annotation_training关系表插入一条记录
        gdaiIntelligentAnnotationTrainingMapper.insert(new GdaiIntelligentAnnotationTraining(intelligentAnnotationId, trainId, userId, date, userId, date));
        //3.拼装启动job任务参数
        JobTemplateObject job = new JobTemplateObject();
        job.bizType = "intelligent_annotation_model";
        job.bizId = String.valueOf(trainId);
        job.bizEnv = LabelUtils.getBizEnvLabelStr();
        job.name = "train-job-annotation-" + trainId;
        job.core = 2;
        job.memorySize = "16G";
        job.gpu = new JobTemplateObject.GPU();
        job.gpu.cardNumber = "1";
        job.gpu.computingPower = "50";
        job.gpu.gpuSize = "8000";
        job.image = "harbor.ccse.ctyun.cn:32000/training/automark:v6";
        job.commandAndArgs = "python3 /root/app/train.py --batch-size=8 --train_path=/datasets/csv/train.csv --test_path=/datasets/csv/test.csv  --result_path=/datasets/csv/nanli.csv --model_out=/out/model_out";
        job.volumes = new JobTemplateObject.Volumes[] { new JobTemplateObject.Volumes("volume-0", datasetPath, "/datasets"), new JobTemplateObject.Volumes("volume-1", modelOutPath, "/out"), new JobTemplateObject.Volumes("volume-2", sourcePath, "/source") };
        JSONObject jsonObject = (JSONObject) JSONObject.toJSON(job);
        log.info("JobTemplateObject jsonObject:" + jsonObject);
        gdaiTrainingModel.setProjectId(projectId);
        gdaiTrainingModel.setTrainId(trainId);
        gdaiTrainingModel.setDatasetId(datasetId);
        gdaiTrainingModel.setTrainName(datasetName + "_智能标注");
        gdaiTrainingModel.setShareFlag("0");
        gdaiTrainingModel.setTrainVersion(hardFilterNum);
        gdaiTrainingModel.setDatasetSource("1");
        gdaiTrainingModel.setModelSavePath(modelOutPath);
        gdaiTrainingModel.setIsCustRes("1");
        gdaiTrainingModel.setComputingPower("50");
        gdaiTrainingModel.setStatus("Pending");
        gdaiTrainingModel.setCardNumber(number);
        gdaiTrainingModel.setProcessUnitType("GPU");
        int core = job.getCore();
        String memorySize = job.getMemorySize();
        JobTemplateObject.GPU gpu = job.getGpu();
        String gpuSize = gpu.getGpuSize();
        gdaiTrainingModel.setCore(String.valueOf(core));
        gdaiTrainingModel.setMemorySize(memorySize);
        gdaiTrainingModel.setGpuSize(gpuSize);
        long size = Long.parseLong(gpuSize) * 1024 * 1024;
        String gpuSizeChange = UnitConvertUtils.getSize(size);
        String env = core + "核CPU" + memorySize + "内存_" + gpuSizeChange;
        gdaiTrainingModel.setTrainingEnvironment(env);
        gdaiTrainingModel.setTrainSource("2");
        gdaiTrainingModelMapper.updateById(gdaiTrainingModel);
        //4.创建job启动训练任务
        gdaiTrainingModel = createJob(k8sInit2, k8sClientOperator, gdaiTrainingModel, job);
    } catch (Exception e) {
        log.info("create job 异常", e);
        throw e;
    }
    return gdaiTrainingModel;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为createJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 创建job训练任务
     *
     * @param k8sInit2
     * @param k8sClientOperator
     * @param gdaiTrainingModel
     * @param job
     * @return
     * @throws Exception
     */
private GdaiTrainingModel createJob(K8sInit2 k8sInit2, K8sClientOperator k8sClientOperator, GdaiTrainingModel gdaiTrainingModel, Object job) throws Exception {
    String namespace = "intelligent-annotation";
    //创建命名空间
    k8sClientOperator.createNamespaceIfNotExist(namespace);
    try {
        V1Job yamlJob = k8sClientOperator.buildJobV2(job);
        V1Job v1Job = k8sClientOperator.createJobV2(yamlJob, namespace);
        String yamlJobStr = io.kubernetes.client.util.Yaml.dump(yamlJob);
        gdaiTrainingModel.setTrainYmlContent(yamlJobStr);
        gdaiTrainingModel.setNameSpace(namespace);
        gdaiTrainingModel.setJobName(v1Job.getMetadata().getName());
        gdaiTrainingModel.setPodLabelSelector("app=" + v1Job.getSpec().getSelector().getMatchLabels().get("app"));
        //通过jobName获取对应创建容器的podName
        V1Pod curV1Pod = getPodByName(k8sInit2, gdaiTrainingModel.getJobName(), namespace);
        String podName = curV1Pod.getMetadata().getName();
        gdaiTrainingModel.setPodName(podName);
        //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
        gdaiTrainingModel.setStatus(curV1Pod.getStatus().getPhase());
        if (StringUtils.isBlank(gdaiTrainingModel.getStatus())) {
            gdaiTrainingModel.setStatus("Unkonwn");
        }
        gdaiTrainingModelMapper.updateById(gdaiTrainingModel);
    } catch (Exception e) {
        log.info("create job 异常", e);
        throw e;
    }
    return gdaiTrainingModel;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1Pod
org.apache.commons.lang3.StringUtils
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为getPodByName的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取容器名称
     *
     * @param k8sInit2
     * @param jobName
     * @param namespace
     * @return
     * @throws ApiException
     */
public V1Pod getPodByName(K8sInit2 k8sInit2, String jobName, String namespace) throws ApiException {
    V1Pod realPod = null;
    ApiClient client = k8sInit2.getConnection();
    CoreV1Api apiInstance = new CoreV1Api(client);
    V1PodList v1PodList = apiInstance.listNamespacedPod(namespace, null, null, null, null, null, null, null, null, null, null);
    if (v1PodList != null) {
        String podName;
        List<V1Pod> podList = v1PodList.getItems();
        for (V1Pod v1Pod : podList) {
            String phase = v1Pod.getStatus().getPhase();
            // 排除一些不正常的pod
            if (StringUtils.isBlank(phase) || "Terminating".equals(phase) || ("Failed".equals(phase) && "UnexpectedAdmissionError".equals(v1Pod.getStatus().getReason()))) {
                continue;
            }
            // 由于是kubernetes的job创建的pod，所以pod名会在job名称后面自动加上一串字母，用"-"连接，所以比较时需要去掉后面一串
            podName = v1Pod.getMetadata().getName().substring(0, v1Pod.getMetadata().getName().lastIndexOf("-"));
            if (jobName.equals(podName)) {
                realPod = v1Pod;
                break;
            }
        }
    }
    return realPod;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为imgclsCheckData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 图片分类智能标注数据集校验
     *
     * @param datasetId
     * @return
     */
public RestResult imgclsCheckData(Long datasetId) {
    try {
        //数据集校验：1.标签数需达到1个以上，才可启动任务
        List<GdaiDatalabel> labelList = gdaiDatalabelMapper.selectList(new EntityWrapper<GdaiDatalabel>().eq("dataset_id", datasetId));
        if (labelList == null || labelList.isEmpty()) {
            return RestResult.genFailResult("标签数需达到1个以上，才可启动任务");
        }
        //2.每个标签下的文件达到10个且未标注文件数大于40(针对主动学习任务)
        for (GdaiDatalabel gdaiDatalabel : labelList) {
            Long datalabelId = gdaiDatalabel.getDatalabelId();
            int fileCount = gdaiDatafileLabelMapper.queryCountByDatalabelId(datasetId, datalabelId);
            if (fileCount < 10) {
                return RestResult.genFailResult("每个标签下的文件达到10个，才可启动任务");
            }
        }
        //查询数据集下未标注的数据数量
        List<String> noMarkList = new ArrayList<>();
        noMarkList.add("1");
        int noMarkNum = gdaiDatafileMapper.queryAllFileNum(datasetId, noMarkList);
        if (noMarkNum < 40) {
            return RestResult.genFailResult("未标注文件数大于40个，才可启动任务");
        }
    } catch (Exception e) {
        log.info("智能标注数据集校验异常：", e);
        return RestResult.genFailResult("智能标注数据集校验异常");
    }
    return RestResult.genSuccessResult("智能标注数据集校验成功");
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为txtEntityCheckData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 文本实体抽取智能标注数据集校验
     *
     * @param datasetId
     * @return
     */
public RestResult txtEntityCheckData(Long datasetId) {
    try {
        //数据集校验：1.标签数需达到1个以上，才可启动任务
        List<GdaiDatalabel> labelList = gdaiDatalabelMapper.selectList(new EntityWrapper<GdaiDatalabel>().eq("dataset_id", datasetId));
        if (labelList == null || labelList.isEmpty()) {
            return RestResult.genFailResult("标签数需达到1个以上，才可启动任务");
        }
        //2.每个标签下的文件达到20个且未标注文件数大于60(针对主动学习任务)
        for (GdaiDatalabel gdaiDatalabel : labelList) {
            Long datalabelId = gdaiDatalabel.getDatalabelId();
            int fileCount = gdaiDatafileLabelMapper.queryCountByDatalabelId(datasetId, datalabelId);
            if (fileCount < 20) {
                return RestResult.genFailResult("每个标签下的文件达到20个，才可启动任务");
            }
        }
        //查询数据集下未标注的数据数量
        List<String> noMarkList = new ArrayList<>();
        noMarkList.add("1");
        int noMarkNum = gdaiDatafileMapper.queryAllFileNum(datasetId, noMarkList);
        if (noMarkNum < 60) {
            return RestResult.genFailResult("未标注文件数大于60个，才可启动任务");
        }
    } catch (Exception e) {
        log.info("智能标注数据集校验异常：", e);
        return RestResult.genFailResult("智能标注数据集校验异常");
    }
    return RestResult.genSuccessResult("智能标注数据集校验成功");
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为objdetCheckData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 物体检测智能标注数据集校验
     *
     * @param datasetId
     * @return
     */
public RestResult objdetCheckData(Long datasetId) {
    try {
        //数据集校验：1.标签数需达到1个以上，才可启动任务
        List<GdaiDatalabel> labelList = gdaiDatalabelMapper.selectList(new EntityWrapper<GdaiDatalabel>().eq("dataset_id", datasetId));
        if (labelList == null || labelList.isEmpty()) {
            return RestResult.genFailResult("标签数需达到1个以上，才可启动任务");
        }
        //2.每个标签下的文件达到10个且未标注文件数大于40(针对主动学习任务)
        for (GdaiDatalabel gdaiDatalabel : labelList) {
            Long datalabelId = gdaiDatalabel.getDatalabelId();
            int fileCount = gdaiDatafileLabelMapper.queryCountByDatalabelId(datasetId, datalabelId);
            if (fileCount < 10) {
                return RestResult.genFailResult("每个标签下的文件达到10个，才可启动任务");
            }
        }
        //查询数据集下未标注的数据数量
        List<String> noMarkList = new ArrayList<>();
        noMarkList.add("1");
        int noMarkNum = gdaiDatafileMapper.queryAllFileNum(datasetId, noMarkList);
        if (noMarkNum < 40) {
            return RestResult.genFailResult("未标注文件数大于40个，才可启动任务");
        }
    } catch (Exception e) {
        log.info("智能标注数据集校验异常：", e);
        return RestResult.genFailResult("智能标注数据集校验异常");
    }
    return RestResult.genSuccessResult("智能标注数据集校验成功");
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatalabel
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelMapper gdaiDatafileLabelMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiIntelligentAnnotationServiceImpl中有一个名为handleIntelligentAnnotationBiz的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void handleIntelligentAnnotationBiz(GdaiTrainingModel trainingModel) {
    List<GdaiIntelligentAnnotationTraining> list = gdaiIntelligentAnnotationTrainingMapper.selectList(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("train_id", trainingModel.getTrainId()));
    GdaiIntelligentAnnotation gdaiIntelligentAnnotation = null;
    Long intelligentAnnotationId = null;
    if (list != null && list.size() > 0) {
        GdaiIntelligentAnnotationTraining gdaiIntelligentAnnotationTraining = list.get(0);
        Long annotationTrainingId = gdaiIntelligentAnnotationTraining.getIntelligentAnnotationId();
        gdaiIntelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(annotationTrainingId);
        if (gdaiIntelligentAnnotation != null) {
            intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
        } else {
            throw new RuntimeException("gdaiIntelligentAnnotation is null");
        }
    }
    if (Objects.equals("Succeeded", trainingModel.getStatus())) {
        if (gdaiIntelligentAnnotation != null) {
            Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
            String csvFilePath = "/datasets/csv/nanli.csv";
            String confirmStatus = "0";
            RestResult restResult = gdaiDatafileLabelService.addBatchFromCsvFile(datasetId, confirmStatus, csvFilePath, 0f);
            if (restResult != null) {
                String code = restResult.getCode();
                if ("200".equals(code)) {
                    log.info("csv文件入库成功");
                    Object data = restResult.getData();
                    JSONObject json = (JSONObject) JSONObject.toJSON(data);
                    int resultCount = (int) json.get("resultCount");
                    if (resultCount == 0) {
                        //更新智能标注hard_filter_status状态为：3-效果确认
                        gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "3", new Date()));
                    } else {
                        //更新智能标注hard_filter_status状态为：2-难例确认
                        gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "2", new Date()));
                    }
                } else {
                    log.info("csv文件入库失败", restResult.getMessage());
                    GdaiIntelligentAnnotation intelligentAnnotation = new GdaiIntelligentAnnotation();
                    intelligentAnnotation.setIntelligentAnnotationId(intelligentAnnotationId);
                    intelligentAnnotation.setStatus("S0F");
                    intelligentAnnotation.setModifyTime(new Date());
                    gdaiIntelligentAnnotationMapper.updateById(intelligentAnnotation);
                }
            }
        }
    } else if (Objects.equals("Failed", trainingModel.getStatus())) {
        gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "S0F", "1", new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.mapper.Wrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
org.springframework.stereotype.Service
java.util.Date
java.util.List
java.util.Objects
### 类级别的变量
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private GdaiDatafileLabelService gdaiDatafileLabelService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiLicenseInfoServiceImpl中有一个名为queryLicenseInfoList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryLicenseInfoList(GdaiLicenseInfoVo gdaiLicenseInfoVo) {
    log.info("GdaiLicenseInfoServiceImpl.queryLicenseInfoList params: [{}]", JSON.toJSONString(gdaiLicenseInfoVo));
    Long projectId = gdaiLicenseInfoVo.getProjectId();
    String bizId = gdaiLicenseInfoVo.getBizId();
    if (projectId == null) {
        RestResult.genFailResult("项目ID不能为空");
    }
    if (StringUtils.isBlank(bizId)) {
        RestResult.genFailResult("bizId不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    long userId = user.getId();
    UiPage<GdaiLicenseInfoVo> uiPage = new UiPage<>();
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    List<GdaiLicenseInfoVo> list = new ArrayList<>();
    Page<GdaiLicenseInfo> gdaiLicenseInfoPage;
    //接下来判断用户角色，如果是超管或AI团队管理员则展示该项目下所有算法配置的lincense
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        EntityWrapper<GdaiLicenseInfo> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId).eq("biz_id", bizId);
        wrapper.orderDesc(desc);
        gdaiLicenseInfoPage = gdaiLicenseInfoService.selectPage(new Page<>(gdaiLicenseInfoVo.getPageNumber(), gdaiLicenseInfoVo.getPageCount()), wrapper);
    } else {
        EntityWrapper<GdaiLicenseInfo> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId).eq("biz_id", bizId).eq("creator_id", userId);
        wrapper.orderDesc(desc);
        //如果用户是普通角色，则展示该用户在项目下创建的记录
        gdaiLicenseInfoPage = gdaiLicenseInfoService.selectPage(new Page<>(gdaiLicenseInfoVo.getPageNumber(), gdaiLicenseInfoVo.getPageCount()), wrapper);
    }
    if (gdaiLicenseInfoPage != null && gdaiLicenseInfoPage.getRecords().size() > 0) {
        List<GdaiLicenseInfo> records = gdaiLicenseInfoPage.getRecords();
        for (GdaiLicenseInfo gdaiLicenseInfo : records) {
            gdaiLicenseInfoVo = new GdaiLicenseInfoVo();
            BeanUtils.copyProperties(gdaiLicenseInfo, gdaiLicenseInfoVo);
            Long creatorId = gdaiLicenseInfo.getCreatorId();
            User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
            if (userInfo != null) {
                gdaiLicenseInfoVo.setCreatorName(userInfo.getUsername());
            }
            list.add(gdaiLicenseInfoVo);
        }
        uiPage.setTotal(gdaiLicenseInfoPage.getTotal());
        uiPage.setPageSize(gdaiLicenseInfoPage.getSize());
        uiPage.setPages(gdaiLicenseInfoPage.getPages());
        uiPage.setPageNum(gdaiLicenseInfoPage.getCurrent());
        uiPage.setList(list);
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiLicenseInfo
com.eshore.gdai.trainingcenter.service.GdaiLicenseInfoService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiLicenseInfoVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiLicenseInfoService gdaiLicenseInfoService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiLicenseInfoServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiLicenseInfo gdaiLicenseInfo) {
    log.info("GdaiLicenseInfoServiceImpl.add params: [{}]", JSON.toJSONString(gdaiLicenseInfo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long projectId = gdaiLicenseInfo.getProjectId();
    Long servingId = gdaiLicenseInfo.getServingId();
    String license = gdaiLicenseInfo.getLicense();
    String bizId = gdaiLicenseInfo.getBizId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (servingId == null) {
        return RestResult.genFailResult("服务部署ID不能为空");
    }
    if (StringUtils.isBlank(license)) {
        return RestResult.genFailResult("license字符串不能为空");
    }
    if (StringUtils.isBlank(bizId)) {
        return RestResult.genFailResult("业务ID不能为空");
    }
    try {
        Date curDate = new Date();
        gdaiLicenseInfo.setCreatorId(userId);
        gdaiLicenseInfo.setCreateTime(curDate);
        gdaiLicenseInfo.setModifyTime(curDate);
        gdaiLicenseInfoMapper.insert(gdaiLicenseInfo);
    } catch (Exception e) {
        log.info("提交异常", e);
        return RestResult.genFailResult("提交异常");
    }
    return RestResult.genSuccessResult("提交成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiLicenseInfo
com.eshore.gdai.trainingcenter.service.GdaiLicenseInfoService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiLicenseInfoMapper gdaiLicenseInfoMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiLicenseInfoServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiLicenseInfo gdaiLicenseInfo) {
    log.info("GdaiLicenseInfoServiceImpl.update params: [{}]", JSON.toJSONString(gdaiLicenseInfo));
    Long licenseInfoId = gdaiLicenseInfo.getLicenseInfoId();
    if (licenseInfoId == null) {
        return RestResult.genFailResult("记录ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        GdaiLicenseInfo licenseInfo = checkGdaiLicenseInfo(user, licenseInfoId);
        BeanUtils.copyProperties(gdaiLicenseInfo, licenseInfo);
        Date curDate = new Date();
        licenseInfo.setModifyTime(curDate);
        licenseInfo.setModifierId(user.getId());
        gdaiLicenseInfoMapper.updateById(licenseInfo);
    } catch (Exception e) {
        log.info("修改异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiLicenseInfo
com.eshore.gdai.trainingcenter.service.GdaiLicenseInfoService
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiLicenseInfoMapper gdaiLicenseInfoMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiLicenseInfoServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiLicenseInfo gdaiLicenseInfo) {
    log.info("GdaiLicenseInfoServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiLicenseInfo));
    Long licenseInfoId = gdaiLicenseInfo.getLicenseInfoId();
    if (licenseInfoId == null) {
        return RestResult.genFailResult("记录ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        checkGdaiLicenseInfo(user, licenseInfoId);
        gdaiLicenseInfoMapper.deleteById(licenseInfoId);
    } catch (Exception e) {
        log.info("删除异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiLicenseInfo
com.eshore.gdai.trainingcenter.service.GdaiLicenseInfoService
org.springframework.stereotype.Service
java.util.Map
### 类级别的变量
@Resource
private GdaiLicenseInfoMapper gdaiLicenseInfoMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiLicenseInfoServiceImpl中有一个名为active的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult active(GdaiLicenseInfo gdaiLicenseInfo) {
    log.info("GdaiLicenseInfoServiceImpl.delete active: [{}]", JSON.toJSONString(gdaiLicenseInfo));
    String license = gdaiLicenseInfo.getLicense();
    Long servingId = gdaiLicenseInfo.getServingId();
    if (StringUtils.isBlank(license)) {
        return RestResult.genFailResult("license字符串不能为空");
    }
    if (servingId == null) {
        return RestResult.genFailResult("服务部署ID不能为空");
    }
    // 获取部署信息和激活URL
    String activeUrl = getActivateUrl(servingId);
    if (activeUrl == null) {
        return RestResult.genFailResult("无法获取激活URL");
    }
    // 准备请求头和请求体
    Map<String, String> headers = new HashMap<>();
    headers.put("Content-Type", "application/json;charset=UTF-8");
    JSONObject body = new JSONObject();
    body.put("license", license);
    // 调用激活接口并处理响应
    try {
        String responseJson = HttpUtils.doPostJson(activeUrl, headers, body);
        log.info("激活服务返回结果：{}", responseJson);
        JSONObject responseObj = JSON.parseObject(responseJson);
        if (responseObj != null) {
            String code = responseObj.getString("code");
            String message = responseObj.getString("message");
            String hostname = responseObj.getString("hostname");
            if ("0".equals(code)) {
                //查询pod信息
                GdaiPod gdaiPod = gdaiPodService.selectGdaiPod(Long.valueOf(servingId), hostname);
                if (gdaiPod != null) {
                    String messages = gdaiPod.getMessage();
                    //messages转为json格式
                    JSONObject jsonObject = JSONObject.parseObject(messages);
                    //将responseObj对象添加到pod的message中
                    jsonObject.put("activeInfo", responseObj);
                    //更新到表中
                    gdaiPod.setMessage(jsonObject.toJSONString());
                    gdaiPodService.updateById(gdaiPod);
                    return RestResult.genSuccessResult("激活成功");
                } else {
                    log.info("pod不存在，servingId: {}", servingId);
                    return RestResult.genFailResult("激活失败，pod不存在，servingId: {}" + servingId);
                }
            } else {
                return RestResult.genFailResult("激活失败：" + message);
            }
        } else {
            return RestResult.genFailResult("激活失败：返回结果为空");
        }
    } catch (Exception e) {
        log.error("激活异常", e);
        return RestResult.genFailResult("激活异常：" + e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.HttpUtils
com.eshore.gdai.trainingcenter.entity.GdaiLicenseInfo
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.service.GdaiLicenseInfoService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.HashMap
java.util.Map
### 类级别的变量
@Resource
private GdaiPodService gdaiPodService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiLicenseInfoServiceImpl中有一个名为getActivateUrl的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据servingId获取激活URL
     *
     * @param servingId
     * @return
     */
private String getActivateUrl(Long servingId) {
    GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
    if (deploy == null) {
        log.error("无法找到部署信息，servingId: {}", servingId);
        return null;
    }
    String serviceUrl = deploy.getServiceUrl();
    if (StringUtils.isBlank(serviceUrl)) {
        log.error("服务URL为空，servingId: {}", servingId);
        return null;
    }
    try {
        JSONArray jsonArray = JSON.parseArray(serviceUrl);
        if (jsonArray.isEmpty()) {
            log.error("服务URL解析为空数组，servingId: {}", servingId);
            return null;
        }
        JSONObject jsonObject = jsonArray.getJSONObject(0);
        String url = jsonObject.getString("url");
        if (url == null) {
            log.error("无法从服务URL中提取URL，servingId: {}", servingId);
            return null;
        }
        // 提取所需的子字符串（保留 http://.../ 部分）
        String urlPart = url.substring(0, url.indexOf("/", url.indexOf("//") + 2) + 1);
        return urlPart + "active";
    } catch (Exception e) {
        log.error("解析服务URL异常", e);
        return null;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiLicenseInfoServiceImpl中有一个名为checkGdaiLicenseInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiLicenseInfo checkGdaiLicenseInfo(User user, Long licenseInfoId) throws TrainginCenterException {
    GdaiLicenseInfo gdaiLicenseInfo = gdaiLicenseInfoMapper.selectById(licenseInfoId);
    if (gdaiLicenseInfo == null) {
        throw new TrainginCenterException("记录不存在");
    } else {
        //判断登录用户角色
        //运营管理员角色
        boolean operAdminRole = SessionUtils.isOperAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(operAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiLicenseInfo.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return gdaiLicenseInfo;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiLicenseInfo
java.util.Map
### 类级别的变量
@Resource
private GdaiLicenseInfoMapper gdaiLicenseInfoMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiMarkJob gdaiMarkJob) {
    log.info("GdaiMarkJobServiceImpl.add params: [{}]", JSON.toJSONString(gdaiMarkJob));
    try {
        //根据任务名称查询是否已存在该任务
        GdaiMarkJob markJob = gdaiMarkJobMapper.selectOne(new GdaiMarkJob(gdaiMarkJob.getJobName()));
        if (markJob != null) {
            return RestResult.genFailResult("该任务已存在");
        }
        //设置数据标注状态:1-未标注 2-待标注 3-标注中 4-标注完成（所有子任务状态都为已提交）5-验收已完成 6-已终止（标注保留）7-已终止（标注不保留）
        gdaiMarkJob.setStatus("1");
        Date curDate = new Date();
        gdaiMarkJob.setCreateTime(curDate);
        gdaiMarkJob.setModifyTime(curDate);
        gdaiMarkJobMapper.insert(gdaiMarkJob);
        gdaiMarkJob.setJobId(gdaiMarkJob.getJobId());
        //进行任务分配并将数据落库
        allotJobs(gdaiMarkJob);
        //任务分配完毕将对应数据集状态标记为S0R-标注中
        Long datasetId = gdaiMarkJob.getDatasetId();
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setAnnotationStatus("S0R");
        gdaiDatasetMapper.updateById(set);
    } catch (Exception e) {
        log.info("新增多人标注任务异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiMarkJob gdaiMarkJob) {
    log.info("GdaiMarkJobServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiMarkJob));
    Long jobId = gdaiMarkJob.getJobId();
    if (jobId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    try {
        //删除之前检查是否存在
        GdaiMarkJob markJob = gdaiMarkJobMapper.selectById(jobId);
        if (markJob == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        //根据jobId获取对应子任务subId
        List<GdaiMarkSubJob> gdaiMarkSubJob = gdaiMarkSubJobMapper.selectList(new EntityWrapper<GdaiMarkSubJob>().eq("job_id", jobId));
        if (gdaiMarkSubJob != null && gdaiMarkSubJob.size() > 0) {
            for (GdaiMarkSubJob subJob : gdaiMarkSubJob) {
                Long subId = subJob.getSubId();
                //删除子任务关系表中对应记录
                gdaiMarkSubJobItemMapper.delete(new EntityWrapper<GdaiMarkSubJobItem>().eq(subId != null, "sub_id", subId));
            }
        }
        //删除关联的子任务记录
        gdaiMarkSubJobMapper.delete(new EntityWrapper<GdaiMarkSubJob>().eq("job_id", jobId));
        //删除任务标注表中记录
        gdaiMarkJobMapper.deleteById(jobId);
        //任务删除后将对应数据集状态标记为S0N-未标注
        Long datasetId = gdaiMarkJob.getDatasetId();
        GdaiDataset set = new GdaiDataset();
        set.setDatasetId(datasetId);
        set.setAnnotationStatus("S0N");
        gdaiDatasetMapper.updateById(set);
    } catch (Exception e) {
        log.info("删除多人标注任务异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为queryJobList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryJobList(GdaiMarkJobVo gdaiMarkJobVo) {
    log.info("GdaiMarkJobServiceImpl.queryJobList params: [{}]", JSON.toJSONString(gdaiMarkJobVo));
    UiPage<GdaiMarkJobVo> uiPage;
    try {
        PageHelper.startPage(gdaiMarkJobVo.getPageNumber(), gdaiMarkJobVo.getPageCount());
        List<GdaiMarkJobVo> gdaiMarkJobList = gdaiMarkJobMapper.queryJobList(gdaiMarkJobVo);
        //总条数
        int total = PageHelper.getTotal();
        PageHelper.remove();
        if (gdaiMarkJobList != null && gdaiMarkJobList.size() > 0) {
            for (GdaiMarkJobVo markJob : gdaiMarkJobList) {
                Long jobId = markJob.getJobId();
                if (jobId != null) {
                    //总任务数量
                    int taskCount = gdaiMarkSubJobMapper.selectCount(new EntityWrapper<GdaiMarkSubJob>().eq("job_id", jobId));
                    markJob.setTaskCount(taskCount);
                    //已提交的任务数量
                    int submittedCount = gdaiMarkSubJobMapper.selectCount(new EntityWrapper<GdaiMarkSubJob>().eq("job_id", jobId).eq("status", "2"));
                    markJob.setSubmittedCount(submittedCount);
                }
            }
        }
        //每页条数
        int pageSize = gdaiMarkJobVo.getPageCount();
        //当前页数
        int pageNum = gdaiMarkJobVo.getPageNumber();
        //总页数
        int pages = 0;
        if (total > 0 && pageSize > 0) {
            pages = (total + pageSize - 1) / pageSize;
        }
        uiPage = new UiPage<>();
        uiPage.setPageSize(pageSize);
        uiPage.setPageNum(pageNum);
        uiPage.setTotal(total);
        uiPage.setPages(pages);
        uiPage.setList(gdaiMarkJobList);
    } catch (Exception e) {
        log.info("查询多人标注任务列表异常", e);
        return RestResult.genFailResult("查询异常");
    } finally {
        PageHelper.remove();
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.plugins.pagination.PageHelper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
com.eshore.gdai.trainingcenter.vo.GdaiMarkJobVo
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为queryJobById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryJobById(GdaiMarkJob gdaiMarkJob) {
    log.info("GdaiMarkJobServiceImpl.queryJobById params: [{}]", JSON.toJSONString(gdaiMarkJob));
    Long jobId = gdaiMarkJob.getJobId();
    if (jobId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    GdaiMarkJob markJob;
    try {
        //根据ID查询该任务详情
        markJob = gdaiMarkJobMapper.selectById(jobId);
        if (markJob == null) {
            return RestResult.genFailResult("该任务不存在");
        }
    } catch (Exception e) {
        log.info("根据任务ID查询任务信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(markJob);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为queryJobProgress的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryJobProgress(GdaiMarkJobVo gdaiMarkJobVo) {
    log.info("GdaiMarkJobServiceImpl.queryJobProgress params: [{}]", JSON.toJSONString(gdaiMarkJobVo));
    Long jobId = gdaiMarkJobVo.getJobId();
    if (jobId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    try {
        GdaiMarkJob markJob = gdaiMarkJobMapper.selectById(jobId);
        if (markJob == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        //获取分组ID，数据集ID
        Long groupId = markJob.getGroupId();
        Long datasetId = markJob.getDatasetId();
        //根据数据集ID查询dataType
        GdaiDataset gdaiDataset = gdaiDatasetMapper.selectById(datasetId);
        if (gdaiDataset != null) {
            Long datasetGroupId = gdaiDataset.getDatasetGroupId();
            GdaiDatasetGroup gdaiDatasetGroup = gdaiDatasetGroupMapper.selectById(datasetGroupId);
            if (gdaiDatasetGroup != null) {
                gdaiMarkJobVo.setDataType(gdaiDatasetGroup.getDataType());
            }
        }
        //根据分组Id获取分组人数
        List<User> groupUsers = FeignServiceHelper.getGroupUsers(userClient, groupId);
        //团队人数
        int groupCount = groupUsers.size();
        //获取任务总量
        int taskCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("mark_status", "1"));
        //查询已删除的数量(暂时不统计删除量)
        //int deleteNum = gdaiMarkSubJobMapper.queryDeleteNum(jobId);
        //查询已标注数量
        Set<Long> set = new HashSet<>();
        List<GdaiMarkSubJob> markSubJobList = gdaiMarkSubJobMapper.selectList(new EntityWrapper<GdaiMarkSubJob>().eq("job_id", jobId));
        if (markSubJobList != null && markSubJobList.size() > 0) {
            for (GdaiMarkSubJob subJob : markSubJobList) {
                Long subId = subJob.getSubId();
                set.add(subId);
            }
        }
        int hasMarkCount = gdaiMarkSubJobItemMapper.selectCount(new EntityWrapper<GdaiMarkSubJobItem>().in("status", "2,3").in("sub_id", set));
        int noMarkCount = gdaiMarkSubJobItemMapper.selectCount(new EntityWrapper<GdaiMarkSubJobItem>().eq("status", "1").in("sub_id", set));
        //计算整体任务完成度
        String completionRate = CalculateUtils.percentInstance(hasMarkCount, hasMarkCount + noMarkCount, 0);
        BeanUtils.copyProperties(markJob, gdaiMarkJobVo);
        gdaiMarkJobVo.setGroupCount(groupCount);
        gdaiMarkJobVo.setTaskCount(taskCount);
        gdaiMarkJobVo.setCompletionRate(completionRate);
        gdaiMarkJobVo.setHasMarkCount(hasMarkCount);
        //gdaiMarkJobVo.setDeleteNum(deleteNum);
    } catch (Exception e) {
        log.info("查询整体任务进度异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiMarkJobVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
com.eshore.gdai.trainingcenter.util.CalculateUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiMarkJob gdaiMarkJob) {
    log.info("GdaiMarkJobServiceImpl.update params: [{}]", JSON.toJSONString(gdaiMarkJob));
    Long jobId = gdaiMarkJob.getJobId();
    Long datasetId = gdaiMarkJob.getDatasetId();
    if (jobId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    try {
        //根据任务ID查询该任务是否存在
        GdaiMarkJob markJob = gdaiMarkJobMapper.selectById(jobId);
        if (markJob == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        Date curDate = new Date();
        gdaiMarkJob.setModifyTime(curDate);
        //根据主任务ID修改子任务状态
        Long modifierId = gdaiMarkJob.getModifierId();
        String masterStatus = gdaiMarkJob.getStatus();
        String status;
        //根据主任务选择的结束状态修改决定子任务结束状态(主任务结束状态：6-已终止（标注保留）7-已终止（标注不保留）)，(子任务结束状态：4-结束标注(标注保留) 5-结束标注(标注不保留))
        if ("5".equals(masterStatus)) {
            status = "6";
            gdaiMarkSubJobMapper.updateByJobId(status, modifierId, curDate, jobId);
            //任务终止将对应数据集状态标记为S0E-标注完成
            GdaiDataset gdaiDataset = new GdaiDataset();
            gdaiDataset.setDatasetId(datasetId);
            gdaiDataset.setAnnotationStatus("S0E");
            gdaiDatasetMapper.updateById(gdaiDataset);
        } else if ("6".equals(masterStatus)) {
            //需要保存多人标注已标注的信息
            //9-任务结束中
            gdaiMarkJob.setStatus("9");
            gdaiMarkJobMapper.updateById(gdaiMarkJob);
            //另起线程结束任务
            GdaiMarkJobServiceImpl gdaiMarkJobServiceImpl = new GdaiMarkJobServiceImpl();
            uploadThreadPool.execute(new GdaiMarkJobServiceImpl.StartUpdateJobStatus(transactionManager, transactionStatuses, sqlSessionTemplate, gdaiMarkSubJobItemMapper, gdaiDatafileLabelTempMapper, gdaiMarkJobMapper, gdaiMarkSubJobMapper, gdaiDatasetMapper, gdaiMarkJobServiceImpl, jobId, modifierId, datasetId, masterStatus));
        } else if ("7".equals(masterStatus)) {
            //不用保存多人标注已标注的信息
            //9-任务结束中
            gdaiMarkJob.setStatus("9");
            gdaiMarkJobMapper.updateById(gdaiMarkJob);
            //另起线程结束任务
            GdaiMarkJobServiceImpl gdaiMarkJobServiceImpl = new GdaiMarkJobServiceImpl();
            uploadThreadPool.execute(new GdaiMarkJobServiceImpl.StartUpdateJobStatus(transactionManager, transactionStatuses, sqlSessionTemplate, gdaiMarkSubJobItemMapper, gdaiDatafileLabelTempMapper, gdaiMarkJobMapper, gdaiMarkSubJobMapper, gdaiDatasetMapper, gdaiMarkJobServiceImpl, jobId, modifierId, datasetId, masterStatus));
        } else {
            gdaiMarkJobMapper.updateById(gdaiMarkJob);
        }
    } catch (Exception e) {
        log.info("修改任务状态值异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
@Resource
private PlatformTransactionManager transactionManager;
List<TransactionStatus> transactionStatuses = Collections.synchronizedList(new ArrayList<>());

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为deleteTempMark的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//删除临时标注信息
public void deleteTempMark(SqlSessionTemplate sqlSessionTemplate, GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper, GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper, Long jobId) throws Exception {
    long startTime = System.currentTimeMillis();
    // 获取批量方式的sqlsession
    SqlSession batchSqlSession = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);
    try {
        //设置查询所有状态数据
        List<String> allList = new ArrayList<>();
        allList.add("1");
        allList.add("2");
        allList.add("3");
        //设置每批次查询数量为500条
        int batchCount = 500;
        //关联查询该主任务下涉及记录总数
        int tempCount = gdaiMarkSubJobItemMapper.queryOtherCountByJobId(jobId, allList);
        if (tempCount > 0) {
            //该变量为需要执行的批次数
            int batchSize = tempCount / batchCount;
            //该集合存放要删除的数据
            List<GdaiDatafileLabelTemp> tempList;
            //该集合存放要删除的数据
            List<GdaiMarkSubJobItem> itemList;
            //该集合存放要Datafile要把状态改回1-待标注的数据
            List<GdaiDatafile> fileList;
            GdaiMarkSubJobItem gdaiMarkSubJobItem;
            GdaiDatafileLabelTemp gdaiDatafileLabelTemp;
            GdaiDatafile gdaiDatafile;
            //起始值
            int index = 0;
            //该变量表示实际执行循环次数
            int k = 0;
            Date curDate = new Date();
            for (; index < tempCount; ) {
                if (k < batchSize) {
                    GdaiDatafileLabelTempVo gdaiDatafileLabelTempVo = new GdaiDatafileLabelTempVo();
                    gdaiDatafileLabelTempVo.setJobId(jobId);
                    gdaiDatafileLabelTempVo.setIndex(index);
                    gdaiDatafileLabelTempVo.setBatchCount(batchCount);
                    List<GdaiDatafileLabelTempVo> gdaiDatafileLabelTempList = gdaiDatafileLabelTempMapper.queryTempLabelInfo(gdaiDatafileLabelTempVo);
                    if (gdaiDatafileLabelTempList != null && gdaiDatafileLabelTempList.size() > 0) {
                        tempList = new ArrayList<>();
                        itemList = new ArrayList<>();
                        fileList = new ArrayList<>();
                        for (GdaiDatafileLabelTempVo vo : gdaiDatafileLabelTempList) {
                            Long datalabelId = vo.getDatalabelId();
                            if (datalabelId != null) {
                                gdaiDatafileLabelTemp = new GdaiDatafileLabelTemp();
                                gdaiDatafileLabelTemp.setFileLabelId(vo.getFileLabelId());
                                tempList.add(gdaiDatafileLabelTemp);
                            }
                            gdaiMarkSubJobItem = new GdaiMarkSubJobItem();
                            gdaiMarkSubJobItem.setItemId(vo.getItemId());
                            itemList.add(gdaiMarkSubJobItem);
                            gdaiDatafile = new GdaiDatafile();
                            gdaiDatafile.setMarkStatus("1");
                            gdaiDatafile.setDatafileId(vo.getDatafileId());
                            gdaiDatafile.setModifyTime(curDate);
                            fileList.add(gdaiDatafile);
                        }
                        //批量删除
                        if (tempList != null && tempList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelTempMapper.deleteBatchById", tempList);
                        }
                        //批量删除
                        if (itemList != null && itemList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.deleteBatchById", itemList);
                        }
                        //批量更新
                        if (fileList != null && fileList.size() > 0) {
                            batchSqlSession.update("com.eshore.gdai.trainingcenter.repository.GdaiDatafileMapper.updateBatch", fileList);
                        }
                    }
                    log.info("tempData delete, index:" + index + " batchCount:" + batchCount);
                    // 设置下一批下标
                    index = index + batchCount;
                } else {
                    GdaiDatafileLabelTempVo gdaiDatafileLabelTempVo = new GdaiDatafileLabelTempVo();
                    gdaiDatafileLabelTempVo.setJobId(jobId);
                    gdaiDatafileLabelTempVo.setIndex(index);
                    gdaiDatafileLabelTempVo.setBatchCount(batchCount);
                    List<GdaiDatafileLabelTempVo> gdaiDatafileLabelTempList = gdaiDatafileLabelTempMapper.queryTempLabelInfo(gdaiDatafileLabelTempVo);
                    if (gdaiDatafileLabelTempList != null && gdaiDatafileLabelTempList.size() > 0) {
                        tempList = new ArrayList<>();
                        itemList = new ArrayList<>();
                        fileList = new ArrayList<>();
                        for (GdaiDatafileLabelTempVo vo : gdaiDatafileLabelTempList) {
                            Long datalabelId = vo.getDatalabelId();
                            if (datalabelId != null) {
                                gdaiDatafileLabelTemp = new GdaiDatafileLabelTemp();
                                gdaiDatafileLabelTemp.setFileLabelId(vo.getFileLabelId());
                                tempList.add(gdaiDatafileLabelTemp);
                            }
                            gdaiMarkSubJobItem = new GdaiMarkSubJobItem();
                            gdaiMarkSubJobItem.setItemId(vo.getItemId());
                            itemList.add(gdaiMarkSubJobItem);
                            gdaiDatafile = new GdaiDatafile();
                            gdaiDatafile.setMarkStatus("1");
                            gdaiDatafile.setDatafileId(vo.getDatafileId());
                            gdaiDatafile.setModifyTime(curDate);
                            fileList.add(gdaiDatafile);
                        }
                        //批量删除
                        if (tempList != null && tempList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelTempMapper.deleteBatchById", tempList);
                        }
                        //批量删除
                        if (itemList != null && itemList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.deleteBatchById", itemList);
                        }
                        //批量更新
                        if (fileList != null && fileList.size() > 0) {
                            batchSqlSession.update("com.eshore.gdai.trainingcenter.repository.GdaiDatafileMapper.updateBatch", fileList);
                        }
                    }
                    log.info("tempData delete, index:" + index + " batchCount:" + batchCount);
                    // 设置下一批下标
                    index = index + batchCount;
                }
                k++;
            }
            //进行事务提交
            batchSqlSession.commit();
            batchSqlSession.clearCache();
            long endTime = System.currentTimeMillis();
            float excTime = (float) (endTime - startTime) / 1000;
            log.info("结束任务完毕，总耗时：" + excTime + "秒");
        }
    } catch (Exception e) {
        batchSqlSession.rollback();
        throw new Exception("结束任务异常", e);
    } finally {
        if (batchSqlSession != null) {
            batchSqlSession.close();
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabelTemp
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.repository
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelTempVo
org.apache.ibatis.session.ExecutorType
org.apache.ibatis.session.SqlSession
### 类级别的变量
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为queryTaskCount的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTaskCount(GdaiMarkJob gdaiMarkJob) {
    log.info("GdaiMarkJobServiceImpl.queryTaskCount params: [{}]", JSON.toJSONString(gdaiMarkJob));
    Long datasetId = gdaiMarkJob.getDatasetId();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    //根据数据集ID和状态值为1-未标注的查询该数据集下图片总数
    int count = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("mark_status", "1"));
    return RestResult.genSuccessResult(count);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为queryTaskByGroupId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTaskByGroupId(Long groupId) {
    log.info("GdaiMarkJobServiceImpl.queryTaskByGroupId params: [{}]", groupId);
    if (groupId == null) {
        return RestResult.genFailResult("groupId不能为空");
    }
    //查询非5-验收已完成  6-已终止（标注保留）7-已终止（标注不保留）这三种状态的数量
    int count = gdaiMarkJobMapper.selectCount(new EntityWrapper<GdaiMarkJob>().eq("group_id", groupId).notIn("status", "5,6,7"));
    return RestResult.genSuccessResult(count);
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为checkJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult checkJob(GdaiMarkJobVo gdaiMarkJobVo) {
    log.info("GdaiMarkJobServiceImpl.checkJob params: [{}]", JSON.toJSONString(gdaiMarkJobVo));
    Long jobId = gdaiMarkJobVo.getJobId();
    Long modifierId = gdaiMarkJobVo.getModifierId();
    if (jobId == null) {
        return RestResult.genFailResult("主任务ID不能为空");
    }
    Long datasetId;
    try {
        //修改之前查询主任务是否存在
        GdaiMarkJob markJob = gdaiMarkJobMapper.selectById(jobId);
        if (markJob == null) {
            return RestResult.genFailResult("该任务不存在");
        }
        datasetId = markJob.getDatasetId();
        //修改主任务状态为8-任务验收中
        gdaiMarkJobMapper.updateById(new GdaiMarkJob(jobId, "8", modifierId, new Date()));
        //另起线程将所有临时表中标注的文件全部copy到主表中
        GdaiMarkJobServiceImpl gdaiMarkJobServiceImpl = new GdaiMarkJobServiceImpl();
        uploadThreadPool.execute(new GdaiMarkJobServiceImpl.StartCheckJob(transactionManager, transactionStatuses, sqlSessionTemplate, gdaiMarkSubJobItemMapper, gdaiDatafileLabelTempMapper, gdaiMarkJobMapper, gdaiMarkSubJobMapper, gdaiDatasetMapper, gdaiMarkJobServiceImpl, jobId, modifierId, datasetId));
    } catch (Exception e) {
        log.info("验收任务异常", e);
        return RestResult.genFailResult("验收任务异常");
    }
    return RestResult.genSuccessResult("任务验收中");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.service.GdaiMarkJobService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
@Resource
private PlatformTransactionManager transactionManager;
List<TransactionStatus> transactionStatuses = Collections.synchronizedList(new ArrayList<>());

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为copyTempData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//copy临时标注信息
public void copyTempData(SqlSessionTemplate sqlSessionTemplate, GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper, GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper, GdaiMarkJobMapper gdaiMarkJobMapper, GdaiMarkSubJobMapper gdaiMarkSubJobMapper, Long jobId) throws Exception {
    long startTime = System.currentTimeMillis();
    // 获取批量方式的sqlsession
    SqlSession batchSqlSession = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);
    try {
        //设置查询所有状态数据
        List<String> allList = new ArrayList<>();
        allList.add("1");
        allList.add("2");
        allList.add("3");
        //设置每批次查询数量为500条
        int batchCount = 500;
        //关联查询该主任务下涉及记录总数
        int tempCount = gdaiMarkSubJobItemMapper.queryOtherCountByJobId(jobId, allList);
        if (tempCount > 0) {
            //该变量为需要执行的批次数
            int batchSize = tempCount / batchCount;
            //该集合存放copy的数据
            List<GdaiDatafileLabel> datafileLabelList;
            GdaiDatafileLabel gdaiDatafileLabel;
            //该集合存放要修改文件标注状态的数据
            List<GdaiDatafile> datafileList;
            GdaiDatafile gdaiDatafile;
            //该集合存放要删除的数据
            List<GdaiDatafileLabelTemp> tempList;
            GdaiDatafileLabelTemp gdaiDatafileLabelTemp;
            //该集合存放要删除的数据
            List<GdaiMarkSubJobItem> itemList;
            GdaiMarkSubJobItem gdaiMarkSubJobItem;
            //起始值
            int index = 0;
            //该变量表示实际执行循环次数
            int k = 0;
            Date curDate = new Date();
            for (; index < tempCount; ) {
                if (k < batchSize) {
                    GdaiDatafileLabelTempVo gdaiDatafileLabelTempVo = new GdaiDatafileLabelTempVo();
                    gdaiDatafileLabelTempVo.setJobId(jobId);
                    gdaiDatafileLabelTempVo.setIndex(index);
                    gdaiDatafileLabelTempVo.setBatchCount(batchCount);
                    List<GdaiDatafileLabelTempVo> gdaiDatafileLabelTempList = gdaiDatafileLabelTempMapper.queryTempLabelInfo(gdaiDatafileLabelTempVo);
                    if (gdaiDatafileLabelTempList != null && gdaiDatafileLabelTempList.size() > 0) {
                        datafileLabelList = new ArrayList<>();
                        datafileList = new ArrayList<>();
                        tempList = new ArrayList<>();
                        itemList = new ArrayList<>();
                        for (GdaiDatafileLabelTempVo vo : gdaiDatafileLabelTempList) {
                            Long datalabelId = vo.getDatalabelId();
                            if (datalabelId != null) {
                                gdaiDatafileLabel = new GdaiDatafileLabel();
                                BeanUtils.copyProperties(vo, gdaiDatafileLabel);
                                gdaiDatafileLabel.setModifyTime(curDate);
                                datafileLabelList.add(gdaiDatafileLabel);
                            }
                            gdaiDatafile = new GdaiDatafile();
                            gdaiDatafile.setDatafileId(vo.getDatafileId() != null ? vo.getDatafileId() : vo.getDatafileIdItem());
                            gdaiDatafile.setMarkStatus(vo.getStatus());
                            gdaiDatafile.setModifyTime(curDate);
                            datafileList.add(gdaiDatafile);
                            if (datalabelId != null) {
                                gdaiDatafileLabelTemp = new GdaiDatafileLabelTemp();
                                gdaiDatafileLabelTemp.setFileLabelId(vo.getFileLabelId());
                                tempList.add(gdaiDatafileLabelTemp);
                            }
                            gdaiMarkSubJobItem = new GdaiMarkSubJobItem();
                            gdaiMarkSubJobItem.setItemId(vo.getItemId());
                            itemList.add(gdaiMarkSubJobItem);
                        }
                        //批量copy
                        if (datafileLabelList != null && datafileLabelList.size() > 0) {
                            batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelMapper.addBatch", datafileLabelList);
                        }
                        //批量修改文件状态
                        if (datafileList != null && datafileList.size() > 0) {
                            batchSqlSession.update("com.eshore.gdai.trainingcenter.repository.GdaiDatafileMapper.updateBatchForJob", datafileList);
                        }
                        //批量删除
                        if (tempList != null && tempList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelTempMapper.deleteBatchById", tempList);
                        }
                        //批量删除
                        if (itemList != null && itemList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.deleteBatchById", itemList);
                        }
                    }
                    log.info("tempData copy, index:" + index + " batchCount:" + batchCount);
                    // 设置下一批下标
                    index = index + batchCount;
                } else {
                    GdaiDatafileLabelTempVo gdaiDatafileLabelTempVo = new GdaiDatafileLabelTempVo();
                    gdaiDatafileLabelTempVo.setJobId(jobId);
                    gdaiDatafileLabelTempVo.setIndex(index);
                    gdaiDatafileLabelTempVo.setBatchCount(batchCount);
                    List<GdaiDatafileLabelTempVo> gdaiDatafileLabelTempList = gdaiDatafileLabelTempMapper.queryTempLabelInfo(gdaiDatafileLabelTempVo);
                    if (gdaiDatafileLabelTempList != null && gdaiDatafileLabelTempList.size() > 0) {
                        datafileLabelList = new ArrayList<>();
                        datafileList = new ArrayList<>();
                        tempList = new ArrayList<>();
                        itemList = new ArrayList<>();
                        for (GdaiDatafileLabelTempVo vo : gdaiDatafileLabelTempList) {
                            Long datalabelId = vo.getDatalabelId();
                            if (datalabelId != null) {
                                gdaiDatafileLabel = new GdaiDatafileLabel();
                                BeanUtils.copyProperties(vo, gdaiDatafileLabel);
                                gdaiDatafileLabel.setModifyTime(curDate);
                                datafileLabelList.add(gdaiDatafileLabel);
                            }
                            gdaiDatafile = new GdaiDatafile();
                            gdaiDatafile.setDatafileId(vo.getDatafileId() != null ? vo.getDatafileId() : vo.getDatafileIdItem());
                            gdaiDatafile.setMarkStatus(vo.getStatus());
                            gdaiDatafile.setModifyTime(curDate);
                            datafileList.add(gdaiDatafile);
                            if (datalabelId != null) {
                                gdaiDatafileLabelTemp = new GdaiDatafileLabelTemp();
                                gdaiDatafileLabelTemp.setFileLabelId(vo.getFileLabelId());
                                tempList.add(gdaiDatafileLabelTemp);
                            }
                            gdaiMarkSubJobItem = new GdaiMarkSubJobItem();
                            gdaiMarkSubJobItem.setItemId(vo.getItemId());
                            itemList.add(gdaiMarkSubJobItem);
                        }
                        //批量copy
                        if (datafileLabelList != null && datafileLabelList.size() > 0) {
                            batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelMapper.addBatch", datafileLabelList);
                        }
                        //批量修改文件状态
                        if (datafileList != null && datafileList.size() > 0) {
                            batchSqlSession.update("com.eshore.gdai.trainingcenter.repository.GdaiDatafileMapper.updateBatchForJob", datafileList);
                        }
                        //批量删除
                        if (tempList != null && tempList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelTempMapper.deleteBatchById", tempList);
                        }
                        //批量删除
                        if (itemList != null && itemList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.deleteBatchById", itemList);
                        }
                    }
                    log.info("tempData copy, index:" + index + " batchCount:" + batchCount);
                    // 设置下一批下标
                    index = index + batchCount;
                }
                k++;
            }
            //进行事务提交
            batchSqlSession.commit();
            batchSqlSession.clearCache();
            long endTime = System.currentTimeMillis();
            float excTime = (float) (endTime - startTime) / 1000;
            log.info("任务验收完毕，总耗时：" + excTime + "秒");
        }
    } catch (Exception e) {
        batchSqlSession.rollback();
        throw new Exception("拷贝坐标信息异常", e);
    } finally {
        if (batchSqlSession != null) {
            batchSqlSession.close();
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabel
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabelTemp
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.repository
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelTempVo
org.apache.ibatis.session.ExecutorType
org.apache.ibatis.session.SqlSession
org.springframework.beans.BeanUtils
### 类级别的变量
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkJobServiceImpl中有一个名为allotJobs的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 任务分配逻辑
     *
     * @param gdaiMarkJob
     */
public void allotJobs(GdaiMarkJob gdaiMarkJob) {
    log.info("开始标注任务分配: [{}]", JSON.toJSONString(gdaiMarkJob));
    long startTime = System.currentTimeMillis();
    SqlSession batchSqlSession = null;
    try {
        Long datasetId = gdaiMarkJob.getDatasetId();
        Long groupId = gdaiMarkJob.getGroupId();
        Long jobId = gdaiMarkJob.getJobId();
        Long creatorId = gdaiMarkJob.getCreatorId();
        //根据数据集ID查询该数据集下未标注的文件总数
        int picCount = gdaiDatafileMapper.selectCount(new EntityWrapper<GdaiDatafile>().eq("dataset_id", datasetId).eq("mark_status", "1"));
        //获取团队标注成员信息
        List<User> groupUsers = FeignServiceHelper.getGroupUsers(userClient, groupId);
        //获取标注团队总人数
        int totalNumber = groupUsers.size();
        //该map用来存放用户与子任务对应关系数据
        Map<Long, Long> maps = new HashMap<>();
        Date date = new Date();
        if (groupUsers != null && groupUsers.size() > 0) {
            //当数据集文件数量少于需要标注的人数时默认把所有文件给第一个人标注
            if (picCount < totalNumber) {
                //默认取出第一个人放入新的集合中
                User user = groupUsers.get(0);
                groupUsers = new ArrayList<>();
                groupUsers.add(user);
            }
            //每人分配的任务信息落库
            for (User user : groupUsers) {
                GdaiMarkSubJob gdaiMarkSubJob = new GdaiMarkSubJob();
                gdaiMarkSubJob.setJobId(jobId);
                gdaiMarkSubJob.setUserId(user.getId());
                //1-待标注 2-标注中 3-已提交 4-结束标注(标注保留) 5-结束标注(标注不保留) 6-验收已完成
                gdaiMarkSubJob.setStatus("1");
                gdaiMarkSubJob.setCreatorId(creatorId);
                gdaiMarkSubJob.setCreateTime(date);
                gdaiMarkSubJob.setModifyTime(date);
                gdaiMarkSubJobMapper.insert(gdaiMarkSubJob);
                gdaiMarkSubJob.setSubId(gdaiMarkSubJob.getSubId());
                maps.put(user.getId(), gdaiMarkSubJob.getSubId());
            }
        }
        //计算每个人分配的数量
        int perNumber = picCount / totalNumber;
        //计算总体余下的数量
        int remainder = picCount % totalNumber;
        int result = 1;
        // 获取批量方式的sqlsession
        batchSqlSession = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);
        //设置每一批次插入数据为500条
        int defaultBatch = 500;
        int batchCount = defaultBatch;
        //起始值
        int index = 0;
        //该集合存放临时要插入的数据
        List<GdaiMarkSubJobItem> itemList;
        Long userId;
        Long subId;
        for (User groupUser : groupUsers) {
            userId = groupUser.getId();
            subId = maps.get(userId);
            //如果每人分配的数量小于等于每批次的数量，则直接查询
            if (perNumber <= batchCount) {
                batchCount = perNumber;
                List<GdaiDatafileVo> gdaiDatafileVos = gdaiDatafileMapper.queryByPageInfo(new GdaiDatafileVo(datasetId, index, batchCount));
                //获取文件ID执行批量插入
                if (gdaiDatafileVos != null && gdaiDatafileVos.size() > 0) {
                    Long finalJobId = jobId;
                    Long finalSubId = subId;
                    itemList = gdaiDatafileVos.stream().map(datafile -> new GdaiMarkSubJobItem(finalJobId, finalSubId, datafile.getDatafileId(), "1", date, date)).collect(Collectors.toList());
                    result = result * batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.addBatch", itemList);
                    batchSqlSession.commit();
                }
                log.info("index:" + index + " batchCount:" + batchCount + " userId:" + userId);
                // 设置下一批下标
                index = index + batchCount;
            } else {
                //计算每个人已经入库总数，用来判断当前用户是否需要结束循环
                int perSum = 0;
                //该变量为每人需要执行的批次数
                int perBatch = perNumber / batchCount;
                //剩余的图片数
                int perRemainder = perNumber % batchCount;
                //该变量表示实际执行循环次数
                int i = 0;
                for (; index <= picCount; ) {
                    if (perSum == perNumber) {
                        break;
                    }
                    if (i < perBatch) {
                        List<GdaiDatafileVo> gdaiDatafileVos = gdaiDatafileMapper.queryByPageInfo(new GdaiDatafileVo(datasetId, index, batchCount));
                        //获取文件ID执行批量插入
                        if (gdaiDatafileVos != null && gdaiDatafileVos.size() > 0) {
                            Long finalJobId = jobId;
                            Long finalSubId = subId;
                            itemList = gdaiDatafileVos.stream().map(datafile -> new GdaiMarkSubJobItem(finalJobId, finalSubId, datafile.getDatafileId(), "1", date, date)).collect(Collectors.toList());
                            result = result * batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.addBatch", itemList);
                            batchSqlSession.commit();
                            perSum = perSum + itemList.size();
                        }
                        log.info("index:" + index + " batchCount:" + batchCount + " userId:" + userId);
                        // 设置下一批下标
                        index = index + batchCount;
                    } else {
                        batchCount = perRemainder;
                        List<GdaiDatafileVo> gdaiDatafileVos = gdaiDatafileMapper.queryByPageInfo(new GdaiDatafileVo(datasetId, index, batchCount));
                        //获取文件ID执行批量插入
                        if (gdaiDatafileVos != null && gdaiDatafileVos.size() > 0) {
                            Long finalJobId = jobId;
                            Long finalSubId = subId;
                            itemList = gdaiDatafileVos.stream().map(datafile -> new GdaiMarkSubJobItem(finalJobId, finalSubId, datafile.getDatafileId(), "1", date, date)).collect(Collectors.toList());
                            result = result * batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.addBatch", itemList);
                            batchSqlSession.commit();
                            perSum = perSum + itemList.size();
                        }
                        log.info("index:" + index + " batchCount:" + batchCount + " userId:" + userId);
                        index = index + batchCount;
                        //每一轮用户循环完毕，将每批次数量置为默认值
                        batchCount = defaultBatch;
                    }
                    i++;
                }
            }
        }
        //获取最后一个用户ID
        User user = groupUsers.get(groupUsers.size() - 1);
        userId = user.getId();
        subId = maps.get(userId);
        //将剩余的所有图片默认分配给最后一个人标注
        batchCount = remainder;
        List<GdaiDatafileVo> gdaiDatafileVos = gdaiDatafileMapper.queryByPageInfo(new GdaiDatafileVo(datasetId, index, batchCount));
        //获取文件ID执行批量插入
        if (gdaiDatafileVos != null && gdaiDatafileVos.size() > 0) {
            Long finalJobId = jobId;
            Long finalSubId = subId;
            itemList = gdaiDatafileVos.stream().map(datafile -> new GdaiMarkSubJobItem(finalJobId, finalSubId, datafile.getDatafileId(), "1", date, date)).collect(Collectors.toList());
            result = result * batchSqlSession.insert("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.addBatch", itemList);
            batchSqlSession.commit();
        }
        log.info("index:" + index + " batchCount:" + batchCount + " userId:" + userId);
        batchSqlSession.commit();
        batchSqlSession.clearCache();
        long endTime = System.currentTimeMillis();
        float excTime = (float) (endTime - startTime) / 1000;
        log.info("任务分配完毕，总耗时：" + excTime + "秒");
        //任务分配完毕更新主任务状态值为：2-待标注
        gdaiMarkJobMapper.updateById(new GdaiMarkJob(jobId, "2"));
    } catch (Exception e) {
        log.info("任务分配异常", e);
        batchSqlSession.rollback();
    } finally {
        if (batchSqlSession != null) {
            batchSqlSession.close();
        }
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.repository
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
org.apache.ibatis.session.ExecutorType
org.apache.ibatis.session.SqlSession
org.springframework.stereotype.Service
java.util.stream.Collectors
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobItemServiceImpl中有一个名为queryDatafileBySubId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryDatafileBySubId(GdaiMarkSubJobItemVo gdaiMarkSubJobItemVo) {
    log.info("GdaiMarkSubJobItemServiceImpl.queryDatafileBySubId params: [{}]", JSON.toJSONString(gdaiMarkSubJobItemVo));
    Long jobId = gdaiMarkSubJobItemVo.getJobId();
    Long subId = gdaiMarkSubJobItemVo.getSubId();
    Long datasetId = gdaiMarkSubJobItemVo.getDatasetId();
    String dataType = gdaiMarkSubJobItemVo.getDataType();
    String markStatus = gdaiMarkSubJobItemVo.getMarkStatus();
    if (datasetId == null) {
        return RestResult.genFailResult("数据集ID不能为空");
    }
    if (StringUtils.isBlank(dataType)) {
        return RestResult.genFailResult("数据集类型不能为空");
    }
    UiPage<GdaiDatafileVo> uiPage;
    List<GdaiDatafileVo> fileVoList = new ArrayList<>();
    GdaiDatafileVo gdaiDatafileVo;
    List<String> asc = new ArrayList<>();
    asc.add("item_id");
    Page<GdaiMarkSubJobItem> markSubJobItemPage;
    List<Long> subIdList = new ArrayList<>();
    try {
        //根据子任务ID是否为空判断是子任务查询列表还是主任务查询列表
        if (subId == null) {
            //若子任务ID为空则表示根据主任务ID查询所有文件列表
            List<GdaiMarkSubJob> markSubJobList = gdaiMarkSubJobMapper.selectList(new EntityWrapper<GdaiMarkSubJob>().eq("job_id", jobId));
            if (markSubJobList != null && markSubJobList.size() > 0) {
                for (GdaiMarkSubJob subJob : markSubJobList) {
                    Long subId1 = subJob.getSubId();
                    subIdList.add(subId1);
                }
            }
        } else {
            subIdList.add(subId);
        }
        if (StringUtils.isNotBlank(gdaiMarkSubJobItemVo.getMarkStatus())) {
            if ("4".equals(markStatus)) {
                //查询全部文件信息(数据标注状态：1-待标注 2-已标注 3-标注为无效数据 4-查询全部（该状态方便用来查询全部记录）)
                gdaiMarkSubJobItemVo.setMarkStatus("1,2,3");
            } else if ("2".equals(markStatus)) {
                gdaiMarkSubJobItemVo.setMarkStatus("2,3");
            }
        }
        markSubJobItemPage = gdaiMarkSubJobItemService.selectPage(new Page<>(gdaiMarkSubJobItemVo.getPageNumber(), gdaiMarkSubJobItemVo.getPageCount()), new EntityWrapper<GdaiMarkSubJobItem>().in("sub_id", subIdList).in("status", gdaiMarkSubJobItemVo.getMarkStatus()).orderAsc(asc));
        List<String> masterLabelNameList;
        if (markSubJobItemPage != null && markSubJobItemPage.getRecords().size() > 0) {
            List<GdaiMarkSubJobItem> records = markSubJobItemPage.getRecords();
            if ("pic".equalsIgnoreCase(dataType)) {
                for (GdaiMarkSubJobItem subJobItem : records) {
                    Long datafileId = subJobItem.getDatafileId();
                    String status = subJobItem.getStatus();
                    GdaiDatafile gdaiDatafile = gdaiDatafileMapper.selectById(datafileId);
                    if (gdaiDatafile != null) {
                        gdaiDatafileVo = new GdaiDatafileVo();
                        //根据datafileId和datasetId查询该数据集下所有标注坐标
                        List<GdaiDatafileLabelVo> gdaiDatafileLabelVos = gdaiDatafileLabelTempMapper.queryMasterLabelAndOther(new GdaiDatafileLabelTemp(datasetId, datafileId));
                        gdaiDatafileVo.setFileLabels(gdaiDatafileLabelVos);
                        //获取datafileId和datasetId，根据其查询标签名称
                        masterLabelNameList = gdaiDatalabelMapper.queryMasterLabelName(new GdaiDatafile(datafileId, datasetId));
                        gdaiDatafileVo.setLabelName(masterLabelNameList);
                        String iconUrl = gdaiDatafile.getIconUrl();
                        //根据iconUrl去ceph下载对应文件流并转换为base64
                        if (StringUtils.isNotBlank(iconUrl)) {
                            String base64 = FileUtil.getFileStream2Base64(iconUrl);
                            gdaiDatafileVo.setIconBase64(base64);
                            BeanUtils.copyProperties(gdaiDatafile, gdaiDatafileVo);
                            gdaiDatafileVo.setStatus(status);
                            fileVoList.add(gdaiDatafileVo);
                        }
                    }
                }
            } else if ("txt".equalsIgnoreCase(dataType)) {
                List<String> markStatusList = new ArrayList<>();
                if ("4".equals(markStatus)) {
                    markStatusList.add("1");
                    markStatusList.add("2");
                    markStatusList.add("3");
                } else if ("2".equals(markStatus)) {
                    markStatusList.add("2");
                    markStatusList.add("3");
                } else if ("1".equals(markStatus)) {
                    markStatusList.add("1");
                } else {
                    return RestResult.genFailResult("标注类型参数错误");
                }
                for (GdaiMarkSubJobItem subJobItem : records) {
                    Long datafileId = subJobItem.getDatafileId();
                    String status = subJobItem.getStatus();
                    GdaiDatafile gdaiDatafile = gdaiDatafileMapper.selectById(datafileId);
                    if (gdaiDatafile != null) {
                        gdaiDatafileVo = new GdaiDatafileVo();
                        gdaiDatafileVo.setDatafileId(datafileId);
                        gdaiDatafileVo.setDatasetId(datasetId);
                        gdaiDatafileVo.setMarkStatusList(markStatusList);
                        List<GdaiDatafileVo> gdaiDatafiles = gdaiDatafileMapper.queryTempTextInfoById(gdaiDatafileVo);
                        if (gdaiDatafiles != null && gdaiDatafiles.size() > 0) {
                            GdaiDatafileVo datafileVo = gdaiDatafiles.get(0);
                            BeanUtils.copyProperties(datafileVo, gdaiDatafileVo);
                            gdaiDatafileVo.setStatus(status);
                            fileVoList.add(gdaiDatafileVo);
                        }
                    }
                }
            } else if ("video".equalsIgnoreCase(dataType)) {
                for (GdaiMarkSubJobItem subJobItem : records) {
                    Long datafileId = subJobItem.getDatafileId();
                    String status = subJobItem.getStatus();
                    GdaiDatafile gdaiDatafile = gdaiDatafileMapper.selectById(datafileId);
                    if (gdaiDatafile != null) {
                        gdaiDatafileVo = new GdaiDatafileVo();
                        //根据datafileId和datasetId查询该数据集下所有标注坐标
                        List<GdaiDatafileLabelVo> gdaiDatafileLabelVos = gdaiDatafileLabelTempMapper.queryMasterLabelAndOther(new GdaiDatafileLabelTemp(datasetId, datafileId));
                        gdaiDatafileVo.setFileLabels(gdaiDatafileLabelVos);
                        //获取datafileId和datasetId，根据其查询标签名称
                        masterLabelNameList = gdaiDatalabelMapper.queryMasterLabelName(new GdaiDatafile(datafileId, datasetId));
                        gdaiDatafileVo.setLabelName(masterLabelNameList);
                        String iconUrl = gdaiDatafile.getIconUrl();
                        //根据iconUrl去ceph下载对应文件流并转换为base64
                        if (StringUtils.isNotBlank(iconUrl)) {
                            String base64 = FileUtil.getFileStream2Base64(iconUrl);
                            gdaiDatafileVo.setIconBase64(base64);
                            BeanUtils.copyProperties(gdaiDatafile, gdaiDatafileVo);
                            gdaiDatafileVo.setStatus(status);
                            fileVoList.add(gdaiDatafileVo);
                        }
                    }
                }
            } else {
                return RestResult.genFailResult("数据集类型错误");
            }
        }
        uiPage = new UiPage<>();
        uiPage.setTotal(markSubJobItemPage.getTotal());
        uiPage.setPageSize(markSubJobItemPage.getSize());
        uiPage.setPages(markSubJobItemPage.getPages());
        uiPage.setPageNum(markSubJobItemPage.getCurrent());
        uiPage.setList(fileVoList);
    } catch (Exception e) {
        log.info("查询标注文件信息列表异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabelTemp
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobItemService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelVo
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiMarkSubJobItemService gdaiMarkSubJobItemService;
@Resource
private GdaiDatafileMapper gdaiDatafileMapper;
@Resource
private GdaiDatalabelMapper gdaiDatalabelMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobItemServiceImpl中有一个名为queryCountBySubId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryCountBySubId(GdaiMarkSubJobItemVo gdaiMarkSubJobItemVo) {
    log.info("GdaiMarkSubJobItemServiceImpl.queryCountBySubId params: [{}]", JSON.toJSONString(gdaiMarkSubJobItemVo));
    Long jobId = gdaiMarkSubJobItemVo.getJobId();
    Long subId = gdaiMarkSubJobItemVo.getSubId();
    if (jobId == null) {
        return RestResult.genFailResult("主任务ID不能为空");
    }
    GdaiDatafileVo datafileVo = new GdaiDatafileVo();
    try {
        //查询有标注信息和无标注信息全部文件数
        List<String> allList = new ArrayList<>();
        allList.add("1");
        allList.add("2");
        allList.add("3");
        int allNum = gdaiMarkSubJobItemMapper.queryCountByMarkStatus(jobId, subId, allList);
        //查询有标注信息文件数(包括标注为无效数据的)
        List<String> hasMarkList = new ArrayList<>();
        hasMarkList.add("2");
        hasMarkList.add("3");
        int hasMarkNum = gdaiMarkSubJobItemMapper.queryCountByMarkStatus(jobId, subId, hasMarkList);
        //查询无标注信息文件数
        List<String> noMarkList = new ArrayList<>();
        noMarkList.add("1");
        int noMarkNum = gdaiMarkSubJobItemMapper.queryCountByMarkStatus(jobId, subId, noMarkList);
        datafileVo.setAllNum(allNum);
        datafileVo.setHasMarkNum(hasMarkNum);
        datafileVo.setNoMarkNum(noMarkNum);
    } catch (Exception e) {
        log.info("根据子任务ID查询该用户各类型标注文件总数", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(datafileVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiDatafile
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobItemService
com.eshore.gdai.trainingcenter.vo.GdaiDatafileVo
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobItemServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiMarkSubJobItemVo gdaiMarkSubJobItemVo) {
    log.info("GdaiMarkSubJobItemServiceImpl.update params: [{}]" + JSON.toJSONString(gdaiMarkSubJobItemVo));
    Long jobId = gdaiMarkSubJobItemVo.getJobId();
    Long subId = gdaiMarkSubJobItemVo.getSubId();
    Long datafileId = gdaiMarkSubJobItemVo.getDatafileId();
    String markStatus = gdaiMarkSubJobItemVo.getMarkStatus();
    if (datafileId == null) {
        return RestResult.genFailResult("文件ID不能为空");
    }
    if (StringUtils.isBlank(markStatus)) {
        return RestResult.genFailResult("markStatus不能为空");
    }
    List<GdaiMarkSubJobItem> gdaiMarkSubJobItems = null;
    try {
        //根据任务ID和文件ID查询该文件记录是否存在
        Long itemId = null;
        if (jobId != null) {
            gdaiMarkSubJobItems = gdaiMarkSubJobItemMapper.selectList(new EntityWrapper<GdaiMarkSubJobItem>().eq("job_id", jobId).eq("datafile_id", datafileId));
            if (gdaiMarkSubJobItems != null && gdaiMarkSubJobItems.size() > 0) {
                itemId = gdaiMarkSubJobItems.get(0).getItemId();
            } else {
                return RestResult.genFailResult("该文件记录不存在");
            }
        }
        if (subId != null) {
            gdaiMarkSubJobItems = gdaiMarkSubJobItemMapper.selectList(new EntityWrapper<GdaiMarkSubJobItem>().eq("sub_id", subId).eq("datafile_id", datafileId));
            if (gdaiMarkSubJobItems != null && gdaiMarkSubJobItems.size() > 0) {
                itemId = gdaiMarkSubJobItems.get(0).getItemId();
            } else {
                return RestResult.genFailResult("该文件记录不存在");
            }
        }
        //mark_status 数据标注状态：1-待标注 2-已标注 3-标注为无效数据 4-查询全部（该状态方便用来查询全部记录）
        gdaiMarkSubJobItemMapper.updateById(new GdaiMarkSubJobItem(itemId, markStatus, gdaiMarkSubJobItemVo.getModifierId(), new Date()));
    } catch (Exception e) {
        log.info("修改标注状态异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobItemService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobServiceImpl中有一个名为querySubJobList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult querySubJobList(GdaiMarkSubJobVo gdaiMarkSubJobVo) {
    log.info("GdaiMarkSubJobServiceImpl.querySubJobList params: [{}]", JSON.toJSONString(gdaiMarkSubJobVo));
    Long jobId = gdaiMarkSubJobVo.getJobId();
    if (jobId == null) {
        return RestResult.genFailResult("任务ID不能为空");
    }
    UiPage<GdaiMarkSubJobVo> uiPage;
    try {
        PageHelper.startPage(gdaiMarkSubJobVo.getPageNumber(), gdaiMarkSubJobVo.getPageCount());
        List<GdaiMarkSubJobVo> gdaiMarkSubJobList = gdaiMarkSubJobMapper.querySubJobList(gdaiMarkSubJobVo);
        //总条数
        int total = PageHelper.getTotal();
        PageHelper.remove();
        if (gdaiMarkSubJobList != null && gdaiMarkSubJobList.size() > 0) {
            for (GdaiMarkSubJobVo markSubJob : gdaiMarkSubJobList) {
                Long subId = markSubJob.getSubId();
                if (subId != null) {
                    //已标注
                    List<String> hasMark = new ArrayList<>();
                    hasMark.add("2");
                    hasMark.add("3");
                    int hasMarkCount = gdaiMarkSubJobItemMapper.queryCountBySubIdAndStatus(subId, hasMark);
                    markSubJob.setHasMarkCount(hasMarkCount);
                    //待标注
                    List<String> noMark = new ArrayList<>();
                    noMark.add("1");
                    int noMarkCount = gdaiMarkSubJobItemMapper.queryCountBySubIdAndStatus(subId, noMark);
                    markSubJob.setNoMarkCount(noMarkCount);
                    //标注进度
                    String markProgress = CalculateUtils.percentInstance(hasMarkCount, hasMarkCount + noMarkCount, 0);
                    markSubJob.setMarkProgress(markProgress);
                }
            }
        }
        //每页条数
        int pageSize = gdaiMarkSubJobVo.getPageCount();
        //当前页数
        int pageNum = gdaiMarkSubJobVo.getPageNumber();
        //总页数
        int pages = 0;
        if (total > 0 && pageSize > 0) {
            pages = (total + pageSize - 1) / pageSize;
        }
        uiPage = new UiPage<>();
        uiPage.setPageSize(pageSize);
        uiPage.setPageNum(pageNum);
        uiPage.setTotal(total);
        uiPage.setPages(pages);
        uiPage.setList(gdaiMarkSubJobList);
    } catch (Exception e) {
        log.info("查询子任务标注进度异常", e);
        return RestResult.genFailResult("查询异常");
    } finally {
        PageHelper.remove();
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.plugins.pagination.PageHelper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobService
com.eshore.gdai.trainingcenter.util.CalculateUtils
com.eshore.gdai.trainingcenter.vo.GdaiMarkSubJobVo
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiMarkSubJob gdaiMarkSubJob) {
    log.info("GdaiMarkSubJobServiceImpl.update params: [{}]", JSON.toJSONString(gdaiMarkSubJob));
    //数据标注状态：1-待标注 2-标注中 3-已提交 4-结束标注(标注保留) 5-结束标注(标注不保留) 6-验收已完成
    String subStatus = gdaiMarkSubJob.getStatus();
    Long modifierId = gdaiMarkSubJob.getModifierId();
    Long subId = gdaiMarkSubJob.getSubId();
    try {
        Date curDate = new Date();
        //如果状态为4-结束标注(标注保留)，则保留已标注数据(默认为这种状态)；如果状态为5-结束标注(标注不保留)，则删除已标注的数据
        if ("5".equals(subStatus)) {
            //子任务状态改为7-任务结束中
            gdaiMarkSubJobMapper.updateById(new GdaiMarkSubJob(subId, "7", modifierId, curDate));
            //另起线程结束任务
            GdaiMarkSubJobServiceImpl gdaiMarkSubJobServiceImpl = new GdaiMarkSubJobServiceImpl();
            uploadThreadPool.execute(new GdaiMarkSubJobServiceImpl.StartDeleteTempData(transactionManager, transactionStatuses, sqlSessionTemplate, gdaiMarkSubJobItemMapper, gdaiDatafileLabelTempMapper, gdaiMarkSubJobMapper, gdaiMarkSubJobServiceImpl, subId, modifierId, subStatus));
        } else {
            gdaiMarkSubJobMapper.updateById(new GdaiMarkSubJob(subId, subStatus, modifierId, curDate));
        }
    } catch (Exception e) {
        log.info("修改子任务状态值异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobService
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
@Resource
private PlatformTransactionManager transactionManager;
List<TransactionStatus> transactionStatuses = Collections.synchronizedList(new ArrayList<>());

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobServiceImpl中有一个名为deleteTempData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//多人标注子任务结束任务（不保留已标注数据）
public void deleteTempData(SqlSessionTemplate sqlSessionTemplate, GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper, GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper, Long subId) throws Exception {
    long startTime = System.currentTimeMillis();
    // 获取批量方式的sqlsession
    SqlSession batchSqlSession = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);
    try {
        //设置查询所有状态数据
        List<String> allList = new ArrayList<>();
        allList.add("1");
        allList.add("2");
        allList.add("3");
        //设置每批次查询数量为500条
        int batchCount = 500;
        //关联查询该主任务下涉及记录总数
        int tempCount = gdaiMarkSubJobItemMapper.queryOtherCountBySubId(subId, allList);
        if (tempCount > 0) {
            //该变量为需要执行的批次数
            int batchSize = tempCount / batchCount;
            //该集合存放要删除的数据
            List<GdaiDatafileLabelTemp> tempList;
            GdaiDatafileLabelTemp gdaiDatafileLabelTemp;
            //该集合存放要修改的数据
            List<GdaiMarkSubJobItem> itemList;
            GdaiMarkSubJobItem gdaiMarkSubJobItem;
            //起始值
            int index = 0;
            //该变量表示实际执行循环次数
            int k = 0;
            Date curDate = new Date();
            for (; index < tempCount; ) {
                if (k < batchSize) {
                    GdaiDatafileLabelTempVo gdaiDatafileLabelTempVo = new GdaiDatafileLabelTempVo();
                    gdaiDatafileLabelTempVo.setSubId(subId);
                    gdaiDatafileLabelTempVo.setIndex(index);
                    gdaiDatafileLabelTempVo.setBatchCount(batchCount);
                    List<GdaiDatafileLabelTempVo> gdaiDatafileLabelTempList = gdaiDatafileLabelTempMapper.queryTempLabelInfo(gdaiDatafileLabelTempVo);
                    if (gdaiDatafileLabelTempList != null && gdaiDatafileLabelTempList.size() > 0) {
                        tempList = new ArrayList<>();
                        itemList = new ArrayList<>();
                        for (GdaiDatafileLabelTempVo vo : gdaiDatafileLabelTempList) {
                            Long datalabelId = vo.getDatalabelId();
                            if (datalabelId != null) {
                                gdaiDatafileLabelTemp = new GdaiDatafileLabelTemp();
                                gdaiDatafileLabelTemp.setFileLabelId(vo.getFileLabelId());
                                tempList.add(gdaiDatafileLabelTemp);
                            }
                            gdaiMarkSubJobItem = new GdaiMarkSubJobItem();
                            gdaiMarkSubJobItem.setItemId(vo.getItemId());
                            gdaiMarkSubJobItem.setStatus("1");
                            gdaiMarkSubJobItem.setModifyTime(curDate);
                            itemList.add(gdaiMarkSubJobItem);
                        }
                        //批量删除
                        if (tempList != null && tempList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelTempMapper.deleteBatchById", tempList);
                        }
                        //批量修改
                        if (itemList != null && itemList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.updateBatch", itemList);
                        }
                    }
                    log.info("tempData delete, index:" + index + " batchCount:" + batchCount);
                    // 设置下一批下标
                    index = index + batchCount;
                } else {
                    GdaiDatafileLabelTempVo gdaiDatafileLabelTempVo = new GdaiDatafileLabelTempVo();
                    gdaiDatafileLabelTempVo.setSubId(subId);
                    gdaiDatafileLabelTempVo.setIndex(index);
                    gdaiDatafileLabelTempVo.setBatchCount(batchCount);
                    List<GdaiDatafileLabelTempVo> gdaiDatafileLabelTempList = gdaiDatafileLabelTempMapper.queryTempLabelInfo(gdaiDatafileLabelTempVo);
                    if (gdaiDatafileLabelTempList != null && gdaiDatafileLabelTempList.size() > 0) {
                        tempList = new ArrayList<>();
                        itemList = new ArrayList<>();
                        for (GdaiDatafileLabelTempVo vo : gdaiDatafileLabelTempList) {
                            Long datalabelId = vo.getDatalabelId();
                            if (datalabelId != null) {
                                gdaiDatafileLabelTemp = new GdaiDatafileLabelTemp();
                                gdaiDatafileLabelTemp.setFileLabelId(vo.getFileLabelId());
                                tempList.add(gdaiDatafileLabelTemp);
                            }
                            gdaiMarkSubJobItem = new GdaiMarkSubJobItem();
                            gdaiMarkSubJobItem.setItemId(vo.getItemId());
                            gdaiMarkSubJobItem.setStatus("1");
                            gdaiMarkSubJobItem.setModifyTime(curDate);
                            itemList.add(gdaiMarkSubJobItem);
                        }
                        //批量删除
                        if (tempList != null && tempList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelTempMapper.deleteBatchById", tempList);
                        }
                        //批量修改
                        if (itemList != null && itemList.size() > 0) {
                            batchSqlSession.delete("com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper.updateBatch", itemList);
                        }
                    }
                    log.info("tempData delete, index:" + index + " batchCount:" + batchCount);
                    // 设置下一批下标
                    index = index + batchCount;
                }
                k++;
            }
            //进行事务提交
            batchSqlSession.commit();
            batchSqlSession.clearCache();
            long endTime = System.currentTimeMillis();
            float excTime = (float) (endTime - startTime) / 1000;
            log.info("子任务结束完毕，总耗时：" + excTime + "秒");
        }
    } catch (Exception e) {
        batchSqlSession.rollback();
        throw new Exception("子任务结束异常", e);
    } finally {
        if (batchSqlSession != null) {
            batchSqlSession.close();
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDatafileLabelTemp
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.repository.GdaiDatafileLabelTempMapper
com.eshore.gdai.trainingcenter.repository.GdaiMarkSubJobItemMapper
com.eshore.gdai.trainingcenter.vo.GdaiDatafileLabelTempVo
org.apache.ibatis.session.ExecutorType
org.apache.ibatis.session.SqlSession
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatafileLabelTempMapper gdaiDatafileLabelTempMapper;
@Resource
private SqlSessionTemplate sqlSessionTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobServiceImpl中有一个名为updateUserBySubId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateUserBySubId(GdaiMarkSubJob gdaiMarkSubJob) {
    log.info("GdaiMarkSubJobServiceImpl.updateUserBySubId params: [{}]", JSON.toJSONString(gdaiMarkSubJob));
    Long subId = gdaiMarkSubJob.getSubId();
    Long userId = gdaiMarkSubJob.getUserId();
    if (subId == null) {
        return RestResult.genFailResult("子任务ID不能为空");
    }
    if (userId == null) {
        return RestResult.genFailResult("标注人员ID不能为空");
    }
    try {
        //重新分配任务之前查询该任务状态是不是已结束
        GdaiMarkSubJob markSubJob = gdaiMarkSubJobMapper.selectById(subId);
        if (markSubJob == null) {
            return RestResult.genFailResult("该子任务不存在");
        }
        String status = markSubJob.getStatus();
        if (!"4".equals(status) && !"5".equals(status)) {
            return RestResult.genFailResult("请先结束标注再移交");
        }
        gdaiMarkSubJob.setModifyTime(new Date());
        gdaiMarkSubJob.setStatus("1");
        gdaiMarkSubJobMapper.updateById(gdaiMarkSubJob);
    } catch (Exception e) {
        log.info("修改子任务标注人异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobService
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobServiceImpl中有一个名为queryJobByUserId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryJobByUserId(GdaiMarkSubJobVo gdaiMarkSubJobVo) {
    log.info("GdaiMarkSubJobServiceImpl.queryJobByUserId params: [{}]", JSON.toJSONString(gdaiMarkSubJobVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    long userId = user.getId();
    log.info("用户ID: [{}]", userId);
    UiPage<GdaiMarkSubJobVo> uiPage;
    try {
        PageHelper.startPage(gdaiMarkSubJobVo.getPageNumber(), gdaiMarkSubJobVo.getPageCount());
        List<GdaiMarkSubJobVo> markSubJobPage = gdaiMarkSubJobMapper.queryJobByUserId(gdaiMarkSubJobVo);
        //总条数
        int total = PageHelper.getTotal();
        PageHelper.remove();
        if (markSubJobPage != null && markSubJobPage.size() > 0) {
            for (GdaiMarkSubJobVo subJobVo : markSubJobPage) {
                Long subId = subJobVo.getSubId();
                Long datasetId = subJobVo.getDatasetId();
                //根据数据集ID查询数据集类型和名称
                GdaiDataset gdaiDataset = gdaiDatasetMapper.selectById(datasetId);
                if (gdaiDataset != null) {
                    Long datasetGroupId = gdaiDataset.getDatasetGroupId();
                    GdaiDatasetGroup gdaiDatasetGroup = gdaiDatasetGroupMapper.selectById(datasetGroupId);
                    if (gdaiDatasetGroup != null) {
                        subJobVo.setDataType(gdaiDatasetGroup.getDataType());
                    }
                }
                if (subId != null) {
                    //已标注
                    List<String> hasMark = new ArrayList<>();
                    hasMark.add("2");
                    hasMark.add("3");
                    int hasMarkCount = gdaiMarkSubJobItemMapper.queryCountBySubIdAndStatus(subId, hasMark);
                    //全部
                    int allCount = gdaiMarkSubJobItemMapper.selectCount(new EntityWrapper<GdaiMarkSubJobItem>().eq("sub_id", subId));
                    subJobVo.setMarkProgress(hasMarkCount + " / " + allCount);
                }
            }
        }
        //每页条数
        int pageSize = gdaiMarkSubJobVo.getPageCount();
        //当前页数
        int pageNum = gdaiMarkSubJobVo.getPageNumber();
        //总页数
        int pages = 0;
        if (total > 0 && pageSize > 0) {
            pages = (total + pageSize - 1) / pageSize;
        }
        uiPage = new UiPage<>();
        uiPage.setPageSize(pageSize);
        uiPage.setPageNum(pageNum);
        uiPage.setTotal(total);
        uiPage.setPages(pages);
        uiPage.setList(markSubJobPage);
    } catch (Exception e) {
        log.info("查询接收任务异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.plugins.pagination.PageHelper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDataset
com.eshore.gdai.trainingcenter.entity.GdaiDatasetGroup
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJobItem
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobService
com.eshore.gdai.trainingcenter.vo.GdaiMarkSubJobVo
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
@Resource
private GdaiMarkSubJobItemMapper gdaiMarkSubJobItemMapper;
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;
@Resource
private GdaiDatasetGroupMapper gdaiDatasetGroupMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiMarkSubJobServiceImpl中有一个名为queryTaskByUserId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTaskByUserId(Long userId) {
    log.info("GdaiMarkSubJobServiceImpl.queryTaskByUserId params: [{}]", userId);
    if (userId == null) {
        return RestResult.genFailResult("userId不能为空");
    }
    int count = gdaiMarkSubJobMapper.selectCount(new EntityWrapper<GdaiMarkSubJob>().eq("user_id", userId));
    return RestResult.genSuccessResult(count);
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.service.GdaiMarkSubJobService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiModelDeployVo gdaiModelDeployVo) {
    log.info("GdaiModelDeployServiceImpl.add params: [{}]", JSON.toJSONString(gdaiModelDeployVo));
    GdaiModelDeploy gdaiModelDeploy = new GdaiModelDeploy();
    BeanUtils.copyProperties(gdaiModelDeployVo, gdaiModelDeploy);
    Long imageId = gdaiModelDeployVo.getImageId();
    Long projectId = gdaiModelDeployVo.getProjectId();
    String deployName = gdaiModelDeploy.getDeployName();
    Long harborImageId = gdaiModelDeploy.getHarborImageId();
    Long creatorId = gdaiModelDeploy.getCreatorId();
    //        String core = gdaiModelDeploy.getCore();
    //        String memorySize = gdaiModelDeploy.getMemorySize();
    //        String gpuSize = gdaiModelDeploy.getGpuSize();
    //        String commandAndArgs = gdaiModelDeploy.getCommandAndArgs();
    //        String isCustRes = gdaiModelDeploy.getIsCustRes();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (StringUtils.isBlank(deployName)) {
        return RestResult.genFailResult("部署名称不能为空");
    }
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    //        if (StringUtils.isBlank(core)) {
    //            return RestResult.genFailResult("核心数不能为空");
    //        }
    //        if (StringUtils.isBlank(memorySize)) {
    //            return RestResult.genFailResult("内存大小不能为空");
    //        }
    //        if (StringUtils.isBlank(gpuSize)) {
    //            return RestResult.genFailResult("GPU大小不能为空");
    //        }
    //        if (StringUtils.isBlank(commandAndArgs)) {
    //            return RestResult.genFailResult("执行参数不能为空");
    //        }
    //        if (!CommonTools.checkCommandAndArgs(commandAndArgs)) {
    //            return RestResult.genFailResult("执行参数不合法");
    //        }
    try {
        String context = gdaiModelDeploy.getContext();
        JSONObject contextObj = new JSONObject();
        if (StringUtils.isNotEmpty(context)) {
            contextObj = JSON.parseObject(context);
        }
        String core = "";
        String memorySize = "";
        String gpuSize = "0";
        if (contextObj != null && !contextObj.isEmpty()) {
            core = contextObj.getString("core");
            memorySize = contextObj.getString("memory");
            if (contextObj.getJSONObject("gpu") != null) {
                gpuSize = contextObj.getJSONObject("gpu").getString("gpuSize");
            }
        }
        if (StringUtils.isBlank(core)) {
            return RestResult.genFailResult("核心数不能为空");
        }
        if (StringUtils.isBlank(memorySize)) {
            return RestResult.genFailResult("内存大小不能为空");
        }
        RestResult limitsOfResources = resourceQuotaService.reachLimitsOfResources("", GdaiConstant.NAMESPACE_PREFIX + projectId, Integer.parseInt(core), Integer.parseInt(memorySize), //TBD vcuda-core 待添加字段
        Integer.parseInt("0"), Integer.parseInt(gpuSize), // 暂时用不到
        Integer.parseInt("0"));
        if (limitsOfResources != null && limitsOfResources.getSuccess() != 0) {
            return RestResult.genFailResult(limitsOfResources.getMessage());
        }
        //            //算力大小默认设置为50%
        //            gdaiModelDeploy.setComputingPower("50");
        //            //这里默认使用卡片数
        //            gdaiModelDeploy.setCardNumber(number);
        //获取部署所需yaml
        //            JSONObject extendData = new JSONObject();
        //配置模版
        GdaiImage gdaiImage = gdaiImageMapper.selectById(imageId);
        if (gdaiImage == null) {
            return RestResult.genFailResult("该配置模版不存在");
        }
        gdaiModelDeploy.setPubYmlContent(gdaiImage.getPubYmlContent());
        //根据镜像ID获取镜像名称和对应版本
        GdaiHarborImage gdaiHarborImage = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(harborImageId));
        if (gdaiHarborImage == null) {
            return RestResult.genFailResult("该镜像不存在");
        }
        //            String image = gdaiHarborImage.getNewImageName();
        //            //设置镜像
        //            extendData.put("image", image);
        //
        //            //我的模型
        //            if (StringUtils.isNotBlank(gdaiModelDeployVo.getModelSavePath())) {
        //                extendData.put("modelSavePath", gdaiModelDeployVo.getModelSavePath());
        //            }
        //            gdaiModelDeploy.setExtendData(extendData);
        //
        //解决字段非空约束,默认赋值为空
        gdaiModelDeploy.setPubCntrMsg("");
        //不使用字段，以后删除
        gdaiModelDeploy.setPubUrl("");
        gdaiModelDeploy.setCommandAndArgs("");
        gdaiModelDeploy.setGpuSize("");
        gdaiModelDeploy.setCore("0");
        gdaiModelDeploy.setMemorySize("");
        //设置命名空间，按项目划分 gdai-projectId
        gdaiModelDeploy.setPubNamespaceName(GdaiConstant.NAMESPACE_PREFIX + projectId);
        gdaiModelDeploy.setStatus("S2C");
        gdaiModelDeploy.setCreatorId(creatorId);
        gdaiModelDeploy.setCreateTime(new Date());
        gdaiModelDeployMapper.insert(gdaiModelDeploy);
        //            Long deployId = gdaiModelDeploy.getDeployId();
        //            //修改状态为开始部署
        //            gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2C", "0", creatorId, new Date()));
        gdaiDeployModelAsyncTask.startDeployModel(gdaiModelDeploy);
    } catch (Exception e) {
        log.info("模型部署异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("模型部署异常:" + e.getMessage());
    }
    return RestResult.genSuccessResult("开始部署");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.entity.GdaiImage
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
com.eshore.gdai.trainingcenter.util.CommonTools
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiImageMapper gdaiImageMapper;
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private GdaiDeployModelAsyncTask gdaiDeployModelAsyncTask;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为replace的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult replace(GdaiModelDeployVo gdaiModelDeployVo) {
    log.info("GdaiModelDeployServiceImpl.add params: [{}]", JSON.toJSONString(gdaiModelDeployVo));
    GdaiModelDeploy currentGdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(gdaiModelDeployVo.getServingId());
    if (currentGdaiModelDeploy == null) {
        return RestResult.genFailResult("该部署记录不存在");
    }
    //当前deploy设成deleted
    currentGdaiModelDeploy.setDeleted(true);
    gdaiModelDeployMapper.updateById(currentGdaiModelDeploy);
    GdaiModelDeploy gdaiModelDeploy = new GdaiModelDeploy();
    BeanUtils.copyProperties(gdaiModelDeployVo, gdaiModelDeploy);
    Long imageId = gdaiModelDeployVo.getImageId();
    Long projectId = gdaiModelDeployVo.getProjectId();
    String deployName = gdaiModelDeploy.getDeployName();
    Long harborImageId = gdaiModelDeploy.getHarborImageId();
    Long creatorId = gdaiModelDeploy.getCreatorId();
    //        String core = gdaiModelDeploy.getCore();
    //        String memorySize = gdaiModelDeploy.getMemorySize();
    //        String gpuSize = gdaiModelDeploy.getGpuSize();
    //        String commandAndArgs = gdaiModelDeploy.getCommandAndArgs();
    //        String isCustRes = gdaiModelDeploy.getIsCustRes();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (StringUtils.isBlank(deployName)) {
        return RestResult.genFailResult("部署名称不能为空");
    }
    if (harborImageId == null) {
        return RestResult.genFailResult("镜像ID不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    //        if (StringUtils.isBlank(core)) {
    //            return RestResult.genFailResult("核心数不能为空");
    //        }
    //        if (StringUtils.isBlank(memorySize)) {
    //            return RestResult.genFailResult("内存大小不能为空");
    //        }
    //        if (StringUtils.isBlank(gpuSize)) {
    //            return RestResult.genFailResult("GPU大小不能为空");
    //        }
    //        if (StringUtils.isBlank(commandAndArgs)) {
    //            return RestResult.genFailResult("执行参数不能为空");
    //        }
    //        if (!CommonTools.checkCommandAndArgs(commandAndArgs)) {
    //            return RestResult.genFailResult("执行参数不合法");
    //        }
    try {
        String context = gdaiModelDeploy.getContext();
        JSONObject contextObj = new JSONObject();
        if (StringUtils.isNotEmpty(context)) {
            contextObj = JSON.parseObject(context);
        }
        String core = "";
        String memorySize = "";
        String gpuSize = "0";
        if (contextObj != null && !contextObj.isEmpty()) {
            core = contextObj.getString("core");
            memorySize = contextObj.getString("memory");
            if (contextObj.getJSONObject("gpu") != null) {
                gpuSize = contextObj.getJSONObject("gpu").getString("gpuSize");
            }
        }
        if (StringUtils.isBlank(core)) {
            return RestResult.genFailResult("核心数不能为空");
        }
        if (StringUtils.isBlank(memorySize)) {
            return RestResult.genFailResult("内存大小不能为空");
        }
        RestResult limitsOfResources = resourceQuotaService.reachLimitsOfResources("", GdaiConstant.NAMESPACE_PREFIX + projectId, Integer.parseInt(core), Integer.parseInt(memorySize), //TBD vcuda-core 待添加字段
        Integer.parseInt("0"), Integer.parseInt(gpuSize), // 暂时用不到
        Integer.parseInt("0"));
        if (limitsOfResources != null && limitsOfResources.getSuccess() != 0) {
            return RestResult.genFailResult(limitsOfResources.getMessage());
        }
        //            //算力大小默认设置为50%
        //            gdaiModelDeploy.setComputingPower("50");
        //            //这里默认使用卡片数
        //            gdaiModelDeploy.setCardNumber(number);
        //获取部署所需yaml
        //            JSONObject extendData = new JSONObject();
        //配置模版
        GdaiImage gdaiImage = gdaiImageMapper.selectById(imageId);
        if (gdaiImage == null) {
            return RestResult.genFailResult("该配置模版不存在");
        }
        gdaiModelDeploy.setPubYmlContent(gdaiImage.getPubYmlContent());
        //根据镜像ID获取镜像名称和对应版本
        GdaiHarborImage gdaiHarborImage = gdaiHarborImageMapper.selectOne(new GdaiHarborImage(harborImageId));
        if (gdaiHarborImage == null) {
            return RestResult.genFailResult("该镜像不存在");
        }
        //            String image = gdaiHarborImage.getNewImageName();
        //            //设置镜像
        //            extendData.put("image", image);
        //
        //            //我的模型
        //            if (StringUtils.isNotBlank(gdaiModelDeployVo.getModelSavePath())) {
        //                extendData.put("modelSavePath", gdaiModelDeployVo.getModelSavePath());
        //            }
        //            gdaiModelDeploy.setExtendData(extendData);
        //
        //解决字段非空约束,默认赋值为空
        gdaiModelDeploy.setPubCntrMsg("");
        //不使用字段，以后删除
        gdaiModelDeploy.setPubUrl("");
        gdaiModelDeploy.setCommandAndArgs("");
        gdaiModelDeploy.setGpuSize("");
        gdaiModelDeploy.setCore("0");
        gdaiModelDeploy.setMemorySize("");
        //设置命名空间，按项目划分 gdai-projectId
        gdaiModelDeploy.setPubNamespaceName(GdaiConstant.NAMESPACE_PREFIX + projectId);
        gdaiModelDeploy.setStatus("S2C");
        gdaiModelDeploy.setCreatorId(creatorId);
        gdaiModelDeploy.setCreateTime(new Date());
        gdaiModelDeployMapper.insert(gdaiModelDeploy);
        //            Long deployId = gdaiModelDeploy.getDeployId();
        //            //修改状态为开始部署
        //            gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2C", "0", creatorId, new Date()));
        gdaiDeployModelAsyncTask.startReplaceDeployModel(gdaiModelDeploy);
    } catch (Exception e) {
        log.info("模型部署异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("模型部署异常");
    }
    return RestResult.genSuccessResult("开始部署");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.entity.GdaiImage
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
com.eshore.gdai.trainingcenter.util.CommonTools
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiImageMapper gdaiImageMapper;
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private GdaiDeployModelAsyncTask gdaiDeployModelAsyncTask;
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为rollback的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult rollback(Long gdaiModelDeployId) {
    log.info("GdaiModelDeployServiceImpl.rollback params: [{}]", gdaiModelDeployId);
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    try {
        //修复水平越权问题
        GdaiModelDeploy gdaiModelDeploy = checkGdaiModelDeploy(user, gdaiModelDeployId, true);
        gdaiModelDeploy.setDeployId(null);
        gdaiModelDeploy.setDeleted(false);
        gdaiModelDeploy.setStatus("S2C");
        gdaiModelDeploy.setCreatorId(userId);
        gdaiModelDeploy.setCreateTime(new Date());
        gdaiModelDeployMapper.insert(gdaiModelDeploy);
        gdaiDeployModelAsyncTask.startReplaceDeployModel(gdaiModelDeploy);
    } catch (Exception e) {
        log.info("模型部署异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("模型部署异常");
    }
    return RestResult.genSuccessResult("开始部署");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiDeployModelAsyncTask gdaiDeployModelAsyncTask;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiModelDeploy gdaiModelDeploy) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.update params: [{}]", JSON.toJSONString(gdaiModelDeploy));
    Long deployId = gdaiModelDeploy.getDeployId();
    String status = gdaiModelDeploy.getStatus();
    if (deployId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    if (StringUtils.isBlank(status)) {
        return RestResult.genFailResult("状态不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    gdaiModelDeploy = checkGdaiModelDeploy(user, deployId, true);
    gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, status, new Date()));
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiModelDeploy gdaiModelDeploy) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.update params: [{}]", JSON.toJSONString(gdaiModelDeploy));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long deployId = gdaiModelDeploy.getDeployId();
    String shareFlag = gdaiModelDeploy.getShareFlag();
    if (deployId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    GdaiModelDeploy deploy = checkGdaiModelDeploy(user, deployId, false);
    GdaiModelDeploy modelDeploy = new GdaiModelDeploy();
    modelDeploy.setDeployId(deployId);
    modelDeploy.setShareFlag(shareFlag);
    modelDeploy.setModifyTime(new Date());
    gdaiModelDeployMapper.updateById(modelDeploy);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiModelDeployVo gdaiModelDeployVo) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiModelDeployVo));
    Long projectId = gdaiModelDeployVo.getProjectId();
    Long deployId = gdaiModelDeployVo.getDeployId();
    try {
        //根据ID查询该部署记录是否存在
        GdaiModelDeploy modelDeploy = gdaiModelDeployMapper.selectById(deployId);
        if (modelDeploy == null) {
            return RestResult.genFailResult("该部署记录不存在");
        }
        String pubServiceName = modelDeploy.getPubServiceName();
        String pubNamespaceName = modelDeploy.getPubNamespaceName();
        String pubDeploymentName = modelDeploy.getPubDeploymentName();
        String pubPodLabelSelector = modelDeploy.getPubPodLabelSelector();
        //删除部署之前查询该服务状态
        ApiClient clients = k8sInit2.getConnection();
        CoreV1Api apiInstances = new CoreV1Api(clients);
        V1PodList v1PodList = apiInstances.listNamespacedPod(pubNamespaceName, null, null, null, null, pubPodLabelSelector, null, null, null, null, null);
        V1Pod v1Pod;
        String phase = "";
        String nodeIp = "";
        if (v1PodList != null && v1PodList.getItems().size() > 0) {
            v1Pod = v1PodList.getItems().get(0);
            phase = v1Pod.getStatus().getPhase();
            nodeIp = v1Pod.getSpec().getNodeName();
        }
        //删除部署的服务
        if (StringUtils.isNotBlank(pubServiceName) && StringUtils.isNotBlank(pubNamespaceName)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            V1ServiceList v1ServiceList = apiInstance.listNamespacedService(pubNamespaceName, null, null, null, null, null, null, null, null, null, null);
            List<V1Service> items = v1ServiceList.getItems();
            for (V1Service v1Service : items) {
                String name = v1Service.getMetadata().getName();
                if (pubServiceName.equals(name)) {
                    apiInstance.deleteNamespacedService(pubServiceName, pubNamespaceName, null, null, 0, null, "", new V1DeleteOptions());
                    break;
                }
            }
        }
        //删除deployment
        if (StringUtils.isNotBlank(pubDeploymentName) && StringUtils.isNotBlank(pubNamespaceName)) {
            ApiClient client = k8sInit2.getConnection();
            AppsV1Api api = new AppsV1Api(client);
            V1DeploymentList v1DeploymentList = api.listNamespacedDeployment(pubNamespaceName, null, null, null, null, null, null, null, null, null, null);
            List<V1Deployment> items = v1DeploymentList.getItems();
            for (V1Deployment v1Deployment : items) {
                String name = v1Deployment.getMetadata().getName();
                if (pubDeploymentName.equals(name)) {
                    api.deleteNamespacedDeployment(pubDeploymentName, pubNamespaceName, null, null, 0, null, "", new V1DeleteOptions());
                    break;
                }
            }
        }
        gdaiModelDeployMapper.deleteById(deployId);
        return RestResult.genSuccessResult("删除成功");
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        log.info("删除应用部署异常", e);
    }
    return RestResult.genFailResult("删除应用部署异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Deployment
io.kubernetes.client.openapi.models.V1DeploymentList
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
io.kubernetes.client.openapi.models.V1Service
io.kubernetes.client.openapi.models.V1ServiceList
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为queryModelDeploy的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelDeploy(GdaiModelDeployVo gdaiModelDeployVo) {
    log.info("GdaiModelDeployServiceImpl.queryModelDeploy params: [{}]", JSON.toJSONString(gdaiModelDeployVo));
    Long projectId = gdaiModelDeployVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String deploySource = gdaiModelDeployVo.getDeploySource();
    if (StringUtils.isBlank(deploySource)) {
        return RestResult.genFailResult("部署来源不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    //        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(request);
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员创建的任务
        UiPage<GdaiModelDeployVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiModelDeployVo> list = new ArrayList<>();
        Page<GdaiModelDeploy> gdaiModelDeployPage = gdaiModelDeployService.selectPage(new Page<>(gdaiModelDeployVo.getPageNumber(), gdaiModelDeployVo.getPageCount()), new EntityWrapper<GdaiModelDeploy>().eq("project_id", projectId).eq("deploy_source", deploySource).orderDesc(desc));
        if (gdaiModelDeployPage != null && gdaiModelDeployPage.getRecords().size() > 0) {
            List<GdaiModelDeploy> records = gdaiModelDeployPage.getRecords();
            for (GdaiModelDeploy gdaiModelDeploy : records) {
                gdaiModelDeployVo = new GdaiModelDeployVo();
                BeanUtils.copyProperties(gdaiModelDeploy, gdaiModelDeployVo);
                gdaiModelDeployVo.setCore(gdaiModelDeploy.getCore() + "核CPU");
                gdaiModelDeployVo.setMemorySize(gdaiModelDeploy.getMemorySize() + "内存 ");
                gdaiModelDeployVo.setGpuSize(gdaiModelDeploy.getGpuSize() + "GPU");
                Long creatorId = gdaiModelDeploy.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiModelDeployVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiModelDeployVo);
            }
            uiPage.setTotal(gdaiModelDeployPage.getTotal());
            uiPage.setPageSize(gdaiModelDeployPage.getSize());
            uiPage.setPages(gdaiModelDeployPage.getPages());
            uiPage.setPageNum(gdaiModelDeployPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    } else {
        UiPage<GdaiModelDeployVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiModelDeployVo> list = new ArrayList<>();
        Page<GdaiModelDeploy> gdaiModelDeployPage = gdaiModelDeployService.selectPage(new Page<>(gdaiModelDeployVo.getPageNumber(), gdaiModelDeployVo.getPageCount()), new EntityWrapper<GdaiModelDeploy>().eq("project_id", projectId).eq("deploy_source", deploySource).andNew().eq("share_flag", "1").or().eq("creator_id", userId).orderDesc(desc));
        if (gdaiModelDeployPage != null && gdaiModelDeployPage.getRecords().size() > 0) {
            List<GdaiModelDeploy> records = gdaiModelDeployPage.getRecords();
            for (GdaiModelDeploy gdaiModelDeploy : records) {
                gdaiModelDeployVo = new GdaiModelDeployVo();
                BeanUtils.copyProperties(gdaiModelDeploy, gdaiModelDeployVo);
                gdaiModelDeployVo.setCore(gdaiModelDeploy.getCore() + "核CPU");
                gdaiModelDeployVo.setMemorySize(gdaiModelDeploy.getMemorySize() + "内存 ");
                gdaiModelDeployVo.setGpuSize(gdaiModelDeploy.getGpuSize() + "GPU");
                Long creatorId = gdaiModelDeploy.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiModelDeployVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiModelDeployVo);
            }
            uiPage.setTotal(gdaiModelDeployPage.getTotal());
            uiPage.setPageSize(gdaiModelDeployPage.getSize());
            uiPage.setPages(gdaiModelDeployPage.getPages());
            uiPage.setPageNum(gdaiModelDeployPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为queryModelDeployById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelDeployById(GdaiModelDeploy gdaiModelDeploy) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.queryModelDeployById params: [{}]", JSON.toJSONString(gdaiModelDeploy));
    Long deployId = gdaiModelDeploy.getDeployId();
    if (deployId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelDeploy modelDeploy = checkGdaiModelDeploy(user, deployId, true);
    modelDeploy.setCore(modelDeploy.getCore() + "核CPU");
    modelDeploy.setMemorySize(modelDeploy.getMemorySize() + "内存 ");
    modelDeploy.setGpuSize(modelDeploy.getGpuSize() + "GPU");
    return RestResult.genSuccessResult(modelDeploy);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
org.springframework.stereotype.Service
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为queryDeployModelList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<ApplicationVo> queryDeployModelList(Long projectId) {
    try {
        return gdaiModelDeployMapper.queryDeployModelList(projectId);
    } catch (Exception e) {
        log.error(e.getMessage());
        return null;
    }
}
### 类导入的包
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为startService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult startService(GdaiModelDeployVo gdaiModelDeployVo) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.startService params: [{}]", JSON.toJSONString(gdaiModelDeployVo));
    Long projectId = gdaiModelDeployVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long deployId = gdaiModelDeployVo.getDeployId();
    if (deployId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelDeploy gdaiModelDeploy = checkGdaiModelDeploy(user, deployId, true);
    String instances = "1";
    if (StringUtils.isNotEmpty(gdaiModelDeploy.getContext())) {
        JSONObject context = JSON.parseObject(gdaiModelDeploy.getContext());
        if (context != null) {
            instances = context.getString("instances");
        }
    }
    try {
        deploymentService.scaleDeployment("", gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubDeploymentName(), Integer.valueOf(instances));
        gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2C", new Date()));
        return RestResult.genSuccessResult("启动成功");
    } catch (Exception e) {
        log.info("启动异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    //        ApiClient client = k8sInit2.getConnection();
    //        AppsV1Api appsInstance = new AppsV1Api(client);
    //        CoreV1Api apiInstance = new CoreV1Api(client);
    //        // 重启容器， 把其副本修改为实例数， 更新副本的json串
    //        String jsonPatchStr = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\", \"value\": " + instances + " }]";
    //        V1Patch body = new V1Patch(jsonPatchStr);
    //        try {
    //
    //            appsInstance.patchNamespacedDeployment(gdaiModelDeploy.getPubDeploymentName(), gdaiModelDeploy.getPubNamespaceName(), body, null, null, null, null);
    //            gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2C", new Date()));
    //
    //            return RestResult.genSuccessResult("启动中");
    //        } catch (Exception e) {
    //            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    //            log.info("启动异常", e);
    //        }
    gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2T", new Date()));
    return RestResult.genFailResult("启动异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private DeploymentService deploymentService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为stopService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult stopService(GdaiModelDeployVo gdaiModelDeployVo) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.stopService params: [{}]", JSON.toJSONString(gdaiModelDeployVo));
    Long projectId = gdaiModelDeployVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long deployId = gdaiModelDeployVo.getDeployId();
    if (deployId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelDeploy gdaiModelDeploy = checkGdaiModelDeploy(user, deployId, true);
    try {
        deploymentService.scaleDeployment("", gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubDeploymentName(), 0);
        gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2C", new Date()));
        return RestResult.genSuccessResult("停止成功");
    } catch (Exception e) {
        log.info("停止异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    //        ApiClient client = k8sInit2.getConnection();
    //        AppsV1Api appsInstance = new AppsV1Api(client);
    //        CoreV1Api apiInstance = new CoreV1Api(client);
    //        // 停止容器， 把其副本修改为0， 更新副本的json串
    //        String jsonPatchStr = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\", \"value\": " + "0" + " }]";
    //        V1Patch body = new V1Patch(jsonPatchStr);
    //        try {
    //            //查询该容器在那个节点上
    //            String nodeIp = "";
    //            V1PodList v1PodList = apiInstance.listNamespacedPod(gdaiModelDeploy.getPubNamespaceName(), null, null, null, null, gdaiModelDeploy.getPubPodLabelSelector(), null, null, null, null, null);
    //            if (v1PodList != null && v1PodList.getItems().size() > 0) {
    //                V1Pod v1Pod = v1PodList.getItems().get(0);
    //                nodeIp = v1Pod.getSpec().getNodeName();
    //            }
    //            appsInstance.patchNamespacedDeployment(gdaiModelDeploy.getPubDeploymentName(), gdaiModelDeploy.getPubNamespaceName(), body, null, null, null, null);
    //            gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2TC", new Date()));
    //
    //            return RestResult.genSuccessResult("停止成功");
    //        } catch (Exception e) {
    //            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    //            log.info("停止异常", e);
    //        }
    gdaiModelDeployMapper.updateById(new GdaiModelDeploy(deployId, "S2R", new Date()));
    return RestResult.genFailResult("停止异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private DeploymentService deploymentService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为scaleService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult scaleService(GdaiModelDeployVo gdaiModelDeployVo, Long instances) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.scaleService params: [{}]", JSON.toJSONString(gdaiModelDeployVo));
    Long projectId = gdaiModelDeployVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long deployId = gdaiModelDeployVo.getDeployId();
    if (deployId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    if (instances == null) {
        return RestResult.genFailResult("实例数不能为空");
    }
    if (instances <= 0) {
        return RestResult.genFailResult("实例数应大于0");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelDeploy gdaiModelDeploy = checkGdaiModelDeploy(user, deployId, true);
    try {
        scaleDeployment(gdaiModelDeploy, instances);
        return RestResult.genSuccessResult("启动中");
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        log.info("启动异常", e);
    }
    return RestResult.genFailResult("启动异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为scaleDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void scaleDeployment(GdaiModelDeploy gdaiModelDeploy, Long instances) throws Exception {
    if (Long.valueOf(gdaiModelDeploy.getReplicas()) == instances) {
        log.info("无需修改实例数");
        return;
    }
    if (StringUtils.isEmpty(gdaiModelDeploy.getContext())) {
        throw new Exception("未找到原始实例数信息");
    }
    JSONObject context = JSON.parseObject(gdaiModelDeploy.getContext());
    context.put("instances", String.valueOf(instances));
    gdaiModelDeploy.setContext(JSON.toJSONString(context));
    deploymentService.scaleDeployment("", gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubDeploymentName(), Integer.valueOf(String.valueOf(instances)));
    gdaiModelDeploy.setModifyTime(new Date());
    gdaiModelDeployMapper.updateById(gdaiModelDeploy);
    //        ApiClient client = k8sInit2.getConnection();
    //        AppsV1Api appsInstance = new AppsV1Api(client);
    //        CoreV1Api apiInstance = new CoreV1Api(client);
    //        // 重启容器， 把其副本修改为实例数， 更新副本的json串
    //        String jsonPatchStr = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\", \"value\": " + instances + " }]";
    //        V1Patch body = new V1Patch(jsonPatchStr);
    //
    //
    //        appsInstance.patchNamespacedDeployment(gdaiModelDeploy.getPubDeploymentName(), gdaiModelDeploy.getPubNamespaceName(), body, null, null, null, null);
    ////        gdaiModelDeploy.setStatus("S2C");
    //        gdaiModelDeploy.setModifyTime(new Date());
    //        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private K8sInit2 k8sInit2;
@Resource
private DeploymentService deploymentService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为downloadLog的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadLog(Long deployId, HttpServletResponse response, HttpServletRequest request) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.downloadLog params: [{}]", JSON.toJSONString(deployId));
    if (deployId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelDeploy gdaiModelDeploy = checkGdaiModelDeploy(user, deployId, true);
    try {
        String pubPodName = gdaiModelDeploy.getPubPodName();
        if (StringUtils.isBlank(pubPodName)) {
            return RestResult.genFailResult("部署名称不能为空");
        }
        String namespace = gdaiModelDeploy.getPubNamespaceName();
        if (StringUtils.isBlank(namespace)) {
            return RestResult.genFailResult("命名空间不能为空");
        }
        String pubPodLabelSelector = gdaiModelDeploy.getPubPodLabelSelector();
        String fileName = pubPodName + "-" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //获取训练日志
        ApiClient client = k8sInit2.getConnection();
        CoreV1Api apiInstance = new CoreV1Api(client);
        V1PodList v1PodList = apiInstance.listNamespacedPod(namespace, null, null, null, null, pubPodLabelSelector, null, null, null, null, null);
        if (v1PodList == null) {
            return RestResult.genFailResult("Pod不存在");
        }
        // pod完整名称
        String podName = v1PodList.getItems().get(0).getMetadata().getName();
        String podLogs = apiInstance.readNamespacedPodLog(podName, namespace, null, null, null, null, null, null, null, null, null);
        String date = DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);
        String str = "[ " + date + " ]  " + podLogs;
        //设置response的header
        response.setContentType("text/plain;charset=utf-8");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".log");
        response.getOutputStream().write(str.getBytes());
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
com.eshore.gdai.trainingcenter.util.DateUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为download的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult download(Long deployId, String subPath, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiModelDeployServiceImpl.downloadModel params: [{}]", JSON.toJSONString(deployId));
    if (deployId == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //根据模型ID查询该模型状态，若已完成训练则可以去对应路径下载训练完模型
        //修复水平越权问题
        GdaiModelDeploy gdaiModelDeploy = checkGdaiModelDeploy(user, deployId, true);
        String savePath = "";
        //获取保存模型的存储路径
        String context = gdaiModelDeploy.getContext();
        if (StringUtils.isEmpty(context)) {
            return RestResult.genFailResult("下载路径为空");
        }
        JSONObject contextObj = JSON.parseObject(context);
        JSONArray volumes = contextObj.getJSONArray("volumes");
        if (volumes != null && volumes.size() > 0) {
            for (int i = 0; i < volumes.size(); i++) {
                JSONObject volume = volumes.getJSONObject(i);
                if (volume != null && Objects.equals(volume.getString("name"), "volume-0")) {
                    savePath = volume.getString("path");
                    break;
                }
            }
        }
        if (StringUtils.isBlank(savePath)) {
            return RestResult.genFailResult("下载路径为空");
        }
        if (StringUtils.isNotBlank(subPath)) {
            if (subPath.startsWith("/")) {
                savePath += subPath;
            } else {
                savePath += "/" + subPath;
            }
        }
        String fileName = "expect_" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(savePath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.service.GdaiModelDeployService
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Objects
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为buildYmlContent的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildYmlContent(GdaiModelDeploy gdaiModelDeploy) throws Exception {
    try {
        //添加一些容器的初始参数到context中
        gdaiModelDeploy.buildContext();
        log.info("buildYmlContent GdaiModelDeploy context：\n" + gdaiModelDeploy.getContext());
        String ymlContent = YamlUtil.loadYaml(gdaiModelDeploy.getPubYmlContent(), gdaiModelDeploy.getContext());
        gdaiModelDeploy.setPubYmlContent(ymlContent);
        log.info("buildYmlContent GdaiModelDeploy 替换后模板:\n " + ymlContent);
    } catch (Exception ex) {
        log.error("create k8s deployment exception:", ex);
        throw new Exception(ex);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util.YamlUtil
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为createDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void createDeployment(GdaiModelDeploy gdaiModelDeploy) throws Exception {
    try {
        String yamlContent = gdaiModelDeploy.getPubYmlContent();
        DeploymentBo deploymentBo = deploymentService.createDeployment("", gdaiModelDeploy.getPubNamespaceName(), yamlContent);
    } catch (Exception e) {
        throw e;
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.DeploymentBo
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private DeploymentService deploymentService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为createService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void createService(GdaiModelDeploy gdaiModelDeploy) throws Exception {
    try {
        String yamlContent = gdaiModelDeploy.getPubYmlContent();
        ServiceBo serviceBo = serviceService.createService("", gdaiModelDeploy.getPubNamespaceName(), yamlContent);
        JSONArray serviceUrls = new JSONArray();
        List<ServicePortBo> ports = serviceBo.getPorts();
        if (StringUtils.isNotEmpty(gdaiModelDeploy.getServiceUrl())) {
            JSONArray services = JSONArray.parseArray(gdaiModelDeploy.getServiceUrl());
            if (services != null && services.size() > 0) {
                for (int i = 0; i < services.size(); i++) {
                    JSONObject serviceObj = services.getJSONObject(i);
                    for (ServicePortBo port : ports) {
                        if (Objects.equals(serviceObj.getString("port"), port.getTargetPort().toString())) {
                            String url = "http://132.126.207.179:" + port.getNodePort();
                            if (serviceObj.getString("path").startsWith("/")) {
                                url += serviceObj.getString("path");
                            } else {
                                url += "/" + serviceObj.getString("path");
                            }
                            serviceObj.put("url", url);
                            break;
                        }
                    }
                }
                gdaiModelDeploy.setServiceUrl(services.toJSONString());
                return;
            }
        }
        //            if (StringUtils.isNotEmpty(gdaiModelDeploy.getContext())) {
        //                JSONObject context = JSON.parseObject(gdaiModelDeploy.getContext());
        //                if (context.containsKey("services")) {
        //                    JSONArray services = context.getJSONArray("services");
        //                    for (int i = 0; i < services.size(); i++) {
        //                        JSONObject serviceObj = services.getJSONObject(i);
        //                        for (ServicePortBo port : ports) {
        //                            if (Objects.equals(serviceObj.getString("port"), port.getTargetPort().toString())) {
        //                                String url = "http://132.126.207.179:" + port.getNodePort();
        //                                if (serviceObj.getString("path").startsWith("/")) {
        //                                    url += serviceObj.getString("path");
        //                                } else {
        //                                    url += "/" + serviceObj.getString("path");
        //                                }
        //                                serviceObj.put("url", url);
        //                                serviceUrls.add(serviceObj);
        //                                break;
        //                            }
        //                        }
        //                    }
        //                }
        //                gdaiModelDeploy.setServiceUrl(serviceUrls.toJSONString());
        //            }
    } catch (Exception e) {
        throw e;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.k8s.domain.bo.ServiceBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.ServicePortBo
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.List
java.util.Objects
### 类级别的变量
@Resource
private ServiceService serviceService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为replaceDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void replaceDeployment(GdaiModelDeploy gdaiModelDeploy) throws Exception {
    try {
        String yamlContent = gdaiModelDeploy.getPubYmlContent();
        V1Deployment deployment = YamlUtil.loadK8sObject(yamlContent, "Deployment", V1Deployment.class);
        V1Deployment createResult = k8sClientOperator.replaceDeployment(deployment, gdaiModelDeploy.getPubDeploymentName(), gdaiModelDeploy.getPubNamespaceName());
    } catch (Exception e) {
        throw e;
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.models.V1Deployment
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为updateCurrentStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void updateCurrentStatus(GdaiModelDeploy gdaiModelDeploy) {
    //replicas=0,readyReplicas=0	S2T 停止  （原状态为S2TC 停止中才改状态）
    //replicas>0,readyReplicas=0	S2C 启动中/S2E 运行异常    （查pod表有faild就是异常）
    //replicas>0,readyReplicas>0	S2R 运行中
    String status = "";
    String originStatus = gdaiModelDeploy.getStatus();
    Integer replicas = gdaiModelDeploy.getReplicas();
    Integer readyReplicas = gdaiModelDeploy.getReadyReplicas();
    if (replicas == 0 && readyReplicas == 0) {
        if (!originStatus.equals("S2E")) {
            status = "S2T";
        }
    } else if (replicas > 0 && readyReplicas == 0) {
        status = "S2C";
    } else if (replicas > 0 && readyReplicas > 0) {
        status = "S2R";
    } else if (replicas == 0 && readyReplicas > 0) {
        if (!originStatus.equals("S2E")) {
            status = "S2TC";
        }
    } else {
        log.error("deployment status unknow,replicas:" + replicas + ",readyReplicas:" + readyReplicas);
        //status = "S2E";
    }
    if (StringUtils.isNotEmpty(status)) {
        gdaiModelDeploy.setStatus(status);
    }
}
### 类导入的包
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为handleResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void handleResource(DeploymentBo deploymentBo, GdaiModelDeploy gdaiModelDeploy) throws Exception {
    //处理长时间异常的资源
    Boolean failedFlag = false;
    if ("S2C".equals(gdaiModelDeploy.getStatus())) {
        List<GdaiPod> pods = gdaiPodService.selectByBizId(gdaiModelDeploy.getServingId());
        for (GdaiPod pod : pods) {
            if (StringUtils.equals("Failed", pod.getPhase())) {
                failedFlag = true;
                break;
            }
        }
        if (failedFlag) {
            //                Date creationDate = DateUtil.strToDate(deploymentBo.getCreationTimestamp());
            Date creationDate = gdaiModelDeploy.getCreateTime();
            //计算pod创建到现在时间(分钟)
            Long distanceMin = DateUtil.getDistanceMin(creationDate, new Date());
            //如果pod创建到现在超过了预定义的删除时间，就将其状态设置为S0E
            if (distanceMin > 15) {
                gdaiModelDeploy.setStatus("S2E");
                //TBD 先不停，方便排查异常
                // 停止容器， 把其副本修改为0，
                //                    deploymentService.stopDeployment("", gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubDeploymentName());
                gdaiModelDeployMapper.updateForCallback(gdaiModelDeploy);
                log.info("dev_model podCallback update: {} {}", gdaiModelDeploy.getPubDeploymentName(), gdaiModelDeploy.getStatus());
            }
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.util.DateUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiPodService gdaiPodService;
@Resource
private DeploymentService deploymentService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为activeHandle的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void activeHandle(GdaiModelDeploy gdaiModelDeploy) throws Exception {
    //第三方服务激活调用及记录
    //获取服务运行状态：S2R 运行中
    String status = gdaiModelDeploy.getStatus();
    //获取服务来源：2-第三方
    String deploySource = gdaiModelDeploy.getDeploySource();
    //获取服务ID
    Long servingId = gdaiModelDeploy.getServingId();
    //获取context大字段中的active字段，如果为1则需要调用激活接口
    String context = gdaiModelDeploy.getContext();
    JSONObject jsonContext = JSON.parseObject(context);
    String active = jsonContext.getString("active");
    if ("1".equals(active)) {
        if ("S2R".equals(status) && "2".equals(deploySource)) {
            // 获取部署信息和激活URL
            String activeUrl = getActivateUrl(servingId);
            if (StringUtils.isNotBlank(activeUrl)) {
                //根据servingId获取license
                GdaiLicenseInfo licenseInfo = gdaiLicenseInfoMapper.selectOne(new GdaiLicenseInfo(servingId));
                if (licenseInfo != null) {
                    String license = licenseInfo.getLicense();
                    if (StringUtils.isNotBlank(license)) {
                        // 准备请求头和请求体
                        Map<String, String> headers = new HashMap<>();
                        headers.put("Content-Type", "application/json;charset=UTF-8");
                        JSONObject body = new JSONObject();
                        body.put("license", license);
                        // 调用激活接口并处理响应
                        //打印调用前参数
                        log.info("激活服务请求地址：{}", activeUrl);
                        log.info("激活服务请求参数：{}", JSON.toJSONString(body));
                        String responseJson = HttpUtils.doPostJson(activeUrl, headers, body);
                        log.info("激活服务返回结果：{}", responseJson);
                        JSONObject responseObj = JSON.parseObject(responseJson);
                        if (responseObj != null) {
                            String code = responseObj.getString("code");
                            String message = responseObj.getString("message");
                            String hostname = responseObj.getString("hostname");
                            if ("0".equals(code)) {
                                log.info("激活成功：{}", hostname);
                            } else {
                                log.info("激活失败：{}", hostname);
                            }
                            //查询pod信息
                            GdaiPod gdaiPod = gdaiPodService.selectGdaiPod(Long.valueOf(servingId), hostname);
                            if (gdaiPod != null) {
                                String messages = gdaiPod.getMessage();
                                //messages转为json格式
                                JSONObject jsonObject = JSONObject.parseObject(messages);
                                //将responseObj对象添加到pod的message中
                                jsonObject.put("activeInfo", responseObj);
                                //更新到表中
                                gdaiPod.setMessage(jsonObject.toJSONString());
                                gdaiPodService.updateById(gdaiPod);
                            } else {
                                log.info("pod不存在，servingId: {}", servingId);
                            }
                        } else {
                            log.info("激活失败：返回结果为空");
                        }
                    } else {
                        log.info("license为空");
                    }
                }
            } else {
                log.info("无法获取激活URL");
            }
        }
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.utils.HttpUtils
com.eshore.gdai.trainingcenter.entity.GdaiLicenseInfo
com.eshore.gdai.trainingcenter.entity.GdaiPod
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.HashMap
java.util.Map
### 类级别的变量
@Resource
private GdaiPodService gdaiPodService;
@Resource
private GdaiLicenseInfoMapper gdaiLicenseInfoMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为getActivateUrl的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据servingId获取激活URL
     *
     * @param servingId
     * @return
     */
private String getActivateUrl(Long servingId) {
    GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
    if (deploy == null) {
        log.error("无法找到部署信息，servingId: {}", servingId);
        return null;
    }
    String serviceUrl = deploy.getServiceUrl();
    if (StringUtils.isBlank(serviceUrl)) {
        log.error("服务URL为空，servingId: {}", servingId);
        return null;
    }
    try {
        JSONArray jsonArray = JSON.parseArray(serviceUrl);
        if (jsonArray.isEmpty()) {
            log.error("服务URL解析为空数组，servingId: {}", servingId);
            return null;
        }
        JSONObject jsonObject = jsonArray.getJSONObject(0);
        String url = jsonObject.getString("url");
        if (url == null) {
            log.error("无法从服务URL中提取URL，servingId: {}", servingId);
            return null;
        }
        // 提取所需的子字符串（保留 http://.../ 部分）
        String urlPart = url.substring(0, url.indexOf("/", url.indexOf("//") + 2) + 1);
        return urlPart + "active";
    } catch (Exception e) {
        log.error("解析服务URL异常", e);
        return null;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Map
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为checkGdaiModelDeploy的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//查询 修改 true   删除 false
 GdaiModelDeploy checkGdaiModelDeploy(User user, Long gdaiModelDeployId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectById(gdaiModelDeployId);
    if (gdaiModelDeploy == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiModelDeploy.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiModelDeploy.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiModelDeploy.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiModelDeploy;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
org.springframework.stereotype.Service
java.util.Map
java.util.Set
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelDeployServiceImpl中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String regex1 = "^(--[^=]+=[^=]+)*$";
    String regex = "^(?:python(3?)\\s+)(?:/[\\w/]+\\.py|\\.?/[\\w/]+\\.py|\\w+\\.py)\\s*(--[^=]+=[^=]+)*$";
    String[] paths = { "python /path/path1/valid_file.py ", "python3 /path/valid_file.py", "python  ./path/path1/valid_file.py", "python ./path/valid_file.py", "python /valid_file.py", "python ./valid_file.py", "python valid_file.py", "python /path/to/valid_file.py  --my_port=888     --my-id=3333 --id=csl@qq.com", "python /path/to/valid_file.py  --port=888     --id=3333 ", "python /path/to/valid_file.py  --port=888", "java /path/to/valid_file.py  --port=888     --id=3333 ", "python /path/to/invalid_file.py --port=888 dfdaadsf", "python /path/to/invalid_file.py -port=888 ", "python /path/to/invalid_file.py -port=888", "python /path/to/invalid_file.py -port888", "python /path/to/invalid_file.py port888", "python /path/to/invalid_file.py --port888", "python /path/to/valid_file.py --port=888 --id=3333;reboot", "python /path/invalid_file.py/path", "python ./path/invalid_file.py/path", "python /path/path1/invalid_file", "python invalid_file.py/path" };
    String[] paths1 = { "--my_port=888     --my-id=3333 --id=csl@qq.com", "  --port=888     --id=3333 #port", "--port=888", "-port=888", "--port=888 --id=3333;reboot" };
    Pattern pattern = Pattern.compile(regex);
    for (String path : paths) {
        if (path.contains(";")) {
            System.out.println(path + " 不合法字符");
        } else {
            Matcher matcher = pattern.matcher(path);
            if (matcher.matches()) {
                System.out.println(path + " 通过");
            } else {
                System.out.println(path + " 不通过");
            }
        }
    }
}
### 类导入的包
java.util.regex.Matcher
java.util.regex.Pattern
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为checkFileMd5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> checkFileMd5(String md5, String fileName, String modelSavePath) {
    log.info("GdaiModelServiceImpl.checkFileMd5 params: [{}],[{}]", fileName, modelSavePath);
    try {
        Result result = LocalUpload.checkFileMd5(md5, fileName, modelSavePath + GdaiConstant.BREAK_POINT_CONF_PATH, modelSavePath + GdaiConstant.BREAK_POINT_PATH);
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("MD5检查异常", e);
    }
    return RestResult.genFailResult("MD5检查异常");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为breakpointUpload的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> breakpointUpload(GdaiModelVo gdaiModelVo, HttpServletRequest request) {
    log.info("GdaiModelServiceImpl.breakpointUpload params: [{}],[{}],[{}],[{}],[{}]", gdaiModelVo.getId(), gdaiModelVo.getChunks(), gdaiModelVo.getChunk(), gdaiModelVo.getSize(), gdaiModelVo.getName());
    try {
        //获取断点续传参数
        String id = gdaiModelVo.getId();
        int chunks = gdaiModelVo.getChunks();
        int chunk = gdaiModelVo.getChunk();
        long size = gdaiModelVo.getSize();
        String name = gdaiModelVo.getName();
        MultipartFile file = gdaiModelVo.getFile();
        String md5 = gdaiModelVo.getMd5();
        //获取上传根目录
        String modelSavePath = gdaiModelVo.getModelSavePath();
        //拼装上传压缩包目录
        String filePath = modelSavePath + GdaiConstant.BREAK_POINT_PATH;
        String confFilePath = modelSavePath + GdaiConstant.BREAK_POINT_CONF_PATH;
        // 这里的 chunkSize(分片大小) 要与前端传过来的大小一致
        Result result = LocalUpload.fragmentFileUploader(new UploadFileParam(id, chunks, chunk, size, name, file, md5), confFilePath, filePath, 5242880L, request);
        result.setData(filePath);
        String code = result.getCode();
        //这里不一定全都是上传的压缩包
        //状态码为201时表示文件上传完毕，此时对压缩包进行校验
        if ("201".equals(code)) {
            //对压缩包进行合法性检查
            String srcZipPath = filePath + "/" + name;
            //添加不允许的扩展名
            String[] fileTypesArray = disallowedFileType.split(",");
            // 转换字符串数组为List
            List<String> disallowedExtensions = Arrays.stream(fileTypesArray).map(String::trim).collect(Collectors.toList());
            boolean isValid = FileUtil.validateZipFileContainsDisallowedFileTypes(srcZipPath, disallowedExtensions);
            if (!isValid) {
                //校验不通过删除压缩包
                String filePathTemp = filePath + "/" + name;
                if (StringUtils.isNotBlank(filePathTemp)) {
                    File files = FileUtils.getFile(filePathTemp);
                    if (files.exists()) {
                        FileUtil.deleteFile(files);
                    }
                }
                String confFilePathTemp = confFilePath + "/" + name + ".conf";
                if (StringUtils.isNotBlank(confFilePathTemp)) {
                    File confFile = FileUtils.getFile(confFilePathTemp);
                    if (confFile.exists()) {
                        FileUtil.deleteFile(confFile);
                    }
                }
                return RestResult.genFailResult("压缩包为空或者压缩包中包含不允许的文件类型,请删除后重新上传");
            }
        }
        return NovelWebUtils.forReturn(result);
    } catch (Exception e) {
        log.info("模型上传异常", e);
    }
    return RestResult.genFailResult("模型上传失败");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.LocalUpload
com.eshore.gdai.trainingcenter.util.NovelWebUtils
com.eshore.gdai.trainingcenter.vo.Result
com.eshore.gdai.trainingcenter.vo.UploadFileParam
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.web.multipart.MultipartFile
java.io.File
java.util.Arrays
java.util.List
java.util.stream.Collectors
### 类级别的变量
@Autowired
private HttpServletRequest request;
/**
 * 不允许上传的文件类型
 */
@Value("${upload.disallowedFileType}")
private String disallowedFileType;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为deleteBreakpointFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteBreakpointFile(GdaiModelVo gdaiModelVo) {
    log.info("GdaiModelServiceImpl.deleteBreakpointFile params: [{}]" + JSON.toJSONString(gdaiModelVo));
    String fileName = gdaiModelVo.getName();
    String modelSavePath = gdaiModelVo.getModelSavePath();
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("文件名称不能为空");
    }
    if (StringUtils.isBlank(modelSavePath)) {
        return RestResult.genFailResult("模型存放路径不能为空");
    }
    try {
        //拼装文件完整路径
        String filePath = modelSavePath + GdaiConstant.BREAK_POINT_PATH + "/" + fileName;
        String confFilePath = modelSavePath + GdaiConstant.BREAK_POINT_CONF_PATH + "/" + fileName + ".conf";
        if (StringUtils.isNotBlank(filePath)) {
            File file = FileUtils.getFile(filePath);
            if (file.exists()) {
                FileUtil.deleteFile(file);
            }
        }
        if (StringUtils.isNotBlank(confFilePath)) {
            File confFile = FileUtils.getFile(confFilePath);
            if (confFile.exists()) {
                FileUtil.deleteFile(confFile);
            }
        }
    } catch (Exception e) {
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiModelVo gdaiModelVo) {
    log.info("GdaiModelServiceImpl.add params: [{}]", JSON.toJSONString(gdaiModelVo));
    GdaiModel gdaiModel = new GdaiModel();
    BeanUtils.copyProperties(gdaiModelVo, gdaiModel);
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    String modelName = gdaiModel.getModelName();
    String framework = gdaiModel.getFramework();
    String modelVersion = gdaiModel.getModelVersion();
    Long projectId = gdaiModel.getProjectId();
    String shareFlag = gdaiModel.getShareFlag();
    if (StringUtils.isBlank(modelName)) {
        return RestResult.genFailResult("模型名称不能为空");
    }
    if (StringUtils.isBlank(framework)) {
        return RestResult.genFailResult("模型架构不能为空");
    }
    if (StringUtils.isBlank(modelVersion)) {
        return RestResult.genFailResult("模型版本不能为空");
    }
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    try {
        //查询同项目下是否存在同名算法包
        GdaiModel model = gdaiModelMapper.selectOne(new GdaiModel(modelName, modelVersion, projectId, userId));
        if (model != null) {
            return RestResult.genFailResult("该项目下已存在同版本模型");
        }
        //拼装算法包保存路径
        Date curDate = new Date();
        gdaiModel.setCreatorId(userId);
        gdaiModel.setCreateTime(curDate);
        gdaiModel.setModifyTime(curDate);
        gdaiModelMapper.insert(gdaiModel);
        Long modelId = gdaiModel.getModelId();
        //            String modelSavePath = cephUploadPath + "/model/" + projectId + "/" + modelId;
        String modelSavePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.MODEL + "/" + modelId;
        gdaiModelMapper.updateById(new GdaiModel(modelId, modelSavePath));
        String trainModelPath = gdaiModelVo.getTrainModelPath();
        if (StringUtils.isNotBlank(trainModelPath)) {
            FileUtil.createDir(modelSavePath);
            //trainModelPath不为空表示用户执行训练模型保存操作，拷贝原目录下模型到模型管理下
            FileUtils.copyDirectory(FileUtils.getFile(trainModelPath), FileUtils.getFile(modelSavePath));
        }
    } catch (Exception e) {
        log.info("新增模型信息异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.io.File
java.util.Date
### 类级别的变量
@Resource
private GdaiModelMapper gdaiModelMapper;
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiModel gdaiModel) throws TrainginCenterException {
    log.info("GdaiModelServiceImpl.updateShareFlag params: [{}]", JSON.toJSONString(gdaiModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //        Long userId = user.getId();
    Long modelId = gdaiModel.getModelId();
    String shareFlag = gdaiModel.getShareFlag();
    if (modelId == null) {
        return RestResult.genFailResult("模型ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    GdaiModel model = gdaiModelMapper.selectById(modelId);
    if (model == null) {
        return RestResult.genFailResult("该记录不存在");
    }
    //修复水平越权问题
    checkGdaiModel(user, modelId, false);
    //        //修改之前判断当前修改人是否和创建人一致（该条记录的创建者才有修改权限）
    //        Long creatorId = model.getCreatorId();
    //        if (!creatorId.equals(userId)) {
    //            return RestResult.genFailResult("非创建者不能修改该状态");
    //        }
    GdaiModel model2 = new GdaiModel();
    model2.setModelId(modelId);
    model2.setShareFlag(shareFlag);
    model2.setModifyTime(new Date());
    gdaiModelMapper.updateById(model2);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiModelMapper gdaiModelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为saveModelInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult saveModelInfo(GdaiModelVo gdaiModelVo) throws TrainginCenterException {
    log.info("GdaiModelServiceImpl.saveModelInfo params: [{}]", JSON.toJSONString(gdaiModelVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long modelId = gdaiModelVo.getModelId();
    String modelSavePath = gdaiModelVo.getModelSavePath();
    String fileName = gdaiModelVo.getFileName();
    if (modelId == null) {
        return RestResult.genFailResult("模型ID不能为空");
    }
    if (StringUtils.isBlank(modelSavePath)) {
        return RestResult.genFailResult("模型保存路径不能为空");
    }
    if (StringUtils.isBlank(fileName)) {
        return RestResult.genFailResult("模型名称不能为空");
    }
    //修复水平越权问题
    checkGdaiModel(user, modelId, true);
    String srcZipPath;
    try {
        String extension = FilenameUtils.getExtension(fileName);
        if ("zip".equalsIgnoreCase(extension)) {
            srcZipPath = modelSavePath + "/" + fileName;
            //将上传的zip包进行解压
            File zipPath = FileUtils.getFile(srcZipPath);
            List<String> unZipPath = ZipUtil.unZip(zipPath, modelSavePath);
            //解压完毕删除zip文件
            if (zipPath != null) {
                if (zipPath.exists()) {
                    zipPath.delete();
                }
            }
        }
    } catch (Exception e) {
        log.info("保存异常", e);
        return RestResult.genFailResult("保存异常");
    }
    //解压完毕更新路径
    gdaiModelMapper.updateById(new GdaiModel(modelId, modelSavePath));
    return RestResult.genSuccessResult("保存成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.io.FilenameUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.List
### 类级别的变量
@Resource
private GdaiModelMapper gdaiModelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiModel gdaiModel) {
    log.info("GdaiModelServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long modelId = gdaiModel.getModelId();
    if (modelId == null) {
        return RestResult.genFailResult("模型ID不能为空");
    }
    try {
        //修复水平越权问题
        GdaiModel model = checkGdaiModel(user, modelId, false);
        //            GdaiModel model = gdaiModelMapper.selectById(modelId);
        //            if (model == null) {
        //                return RestResult.genFailResult("该模型信息不存在");
        //            }
        //            //判断用户是否是超级管理员,如果是超管则直接删除,如果不是超管,删除之前判断当前用户是否和创建人一致（该条记录的创建者才有删除权限）
        //            Boolean superAdminRole = CommonTools.checkDeletePermission(request, userId, model.getCreatorId());
        //            if (!superAdminRole) {
        //                return RestResult.genFailResult("非创建者不能删除该记录");
        //            }
        Long projectId = model.getProjectId();
        //            String modelSavePath = cephUploadPath + "/model/" + projectId + "/" + modelId;
        String modelSavePath = cephUploadPath + "/" + projectId + "/" + userId + GdaiConstant.MODEL + "/" + modelId;
        if (StringUtils.isNotBlank(modelSavePath)) {
            //删除对应模型文件
            if (StringUtils.isNotBlank(modelSavePath)) {
                File file = FileUtils.getFile(modelSavePath);
                if (file.exists()) {
                    FileUtil.deleteFile(file);
                }
            }
        }
        gdaiModelMapper.deleteById(modelId);
    } catch (Exception e) {
        log.info("删除模型信息异常：[{}]", e);
        return RestResult.genFailResult("删除模型信息异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.util.FileUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量
@Resource
private GdaiModelMapper gdaiModelMapper;
@Autowired
private HttpServletRequest request;
/**
 * cephfs挂载根目录
 */
@Value("${cephUpload.uploadPath}")
private String cephUploadPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为queryModelInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelInfo(GdaiModelVo gdaiModelVo) {
    log.info("GdaiModelServiceImpl.queryModelInfo params: [{}]", JSON.toJSONString(gdaiModelVo));
    Long projectId = gdaiModelVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    String modelName = gdaiModelVo.getModelName();
    String modelVersion = gdaiModelVo.getModelVersion();
    Long userId = user.getId();
    //判断登录用户角色
    //        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(request);
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员上传的算法包
        UiPage<GdaiModelVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiModelVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiModel> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId);
        // 如果newImageName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(modelName)) {
            wrapper.like("model_name", modelName);
        }
        if (StringUtils.isNotBlank(modelVersion)) {
            wrapper.or().like("model_version", modelVersion);
        }
        wrapper.orderDesc(desc);
        Page<GdaiModel> gdaiModelPage = gdaiModelService.selectPage(new Page<>(gdaiModelVo.getPageNumber(), gdaiModelVo.getPageCount()), wrapper);
        if (gdaiModelPage != null && gdaiModelPage.getRecords().size() > 0) {
            List<GdaiModel> records = gdaiModelPage.getRecords();
            for (GdaiModel gdaiModel : records) {
                gdaiModelVo = new GdaiModelVo();
                BeanUtils.copyProperties(gdaiModel, gdaiModelVo);
                Long creatorId = gdaiModel.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiModelVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiModelVo);
            }
            uiPage.setTotal(gdaiModelPage.getTotal());
            uiPage.setPageSize(gdaiModelPage.getSize());
            uiPage.setPages(gdaiModelPage.getPages());
            uiPage.setPageNum(gdaiModelPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    } else {
        UiPage<GdaiModelVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("create_time");
        List<GdaiModelVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiModel> wrapper = new EntityWrapper<>();
        wrapper.eq("project_id", projectId).andNew().eq("share_flag", "1").or().eq("creator_id", userId);
        // 如果modelName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(modelName)) {
            wrapper.like("model_name", modelName);
        }
        // 如果modelVersion非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(modelVersion)) {
            wrapper.or().like("model_version", modelVersion);
        }
        wrapper.orderDesc(desc);
        Page<GdaiModel> gdaiModelPage = gdaiModelService.selectPage(new Page<>(gdaiModelVo.getPageNumber(), gdaiModelVo.getPageCount()), wrapper);
        if (gdaiModelPage != null && gdaiModelPage.getRecords().size() > 0) {
            List<GdaiModel> records = gdaiModelPage.getRecords();
            for (GdaiModel gdaiModel : records) {
                gdaiModelVo = new GdaiModelVo();
                BeanUtils.copyProperties(gdaiModel, gdaiModelVo);
                Long creatorId = gdaiModel.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiModelVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiModelVo);
            }
            uiPage.setTotal(gdaiModelPage.getTotal());
            uiPage.setPageSize(gdaiModelPage.getSize());
            uiPage.setPages(gdaiModelPage.getPages());
            uiPage.setPageNum(gdaiModelPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiModelVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiModelService gdaiModelService;
@Resource
private UserClient userClient;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为queryModelInfoNoPage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelInfoNoPage(GdaiModel gdaiModel) {
    log.info("GdaiModelServiceImpl.queryModelInfoNoPage params: [{}]" + JSON.toJSONString(gdaiModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long projectId = gdaiModel.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //判断登录用户角色
    //        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(request);
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    List<String> desc = new ArrayList<>();
    desc.add("model_id");
    List<String> versionAsc = new ArrayList<>();
    versionAsc.add("model_version");
    List<GdaiModelVo> modelList = new ArrayList<>();
    GdaiModelVo gdaiModelVo;
    List<GdaiModel> gdaiModels = gdaiModelService.selectList(new EntityWrapper<GdaiModel>().eq("project_id", projectId).andNew().eq("share_flag", "1").or().eq("creator_id", userId).orderDesc(desc));
    ArrayList<GdaiModelVo> gdaiModelVos = new ArrayList<>();
    if (gdaiModels != null && gdaiModels.size() > 0) {
        for (GdaiModel model : gdaiModels) {
            gdaiModelVo = new GdaiModelVo();
            BeanUtils.copyProperties(model, gdaiModelVo);
            String modelName = model.getModelName();
            if (StringUtils.isNotBlank(modelName)) {
                List<GdaiModel> models = gdaiModelService.selectList(new EntityWrapper<GdaiModel>().eq("model_name", modelName).orderAsc(versionAsc));
                gdaiModelVo.setList(models);
            }
            modelList.add(gdaiModelVo);
            if (modelList != null && modelList.size() > 0) {
                gdaiModelVos = removeDuplicate(modelList);
            }
        }
    }
    return RestResult.genSuccessResult(gdaiModelVos);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiModelVo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiModelService gdaiModelService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为queryModelInfoById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelInfoById(GdaiModel gdaiModel) {
    log.info("GdaiModelServiceImpl.queryModelInfoById params: [{}]" + JSON.toJSONString(gdaiModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long modelId = gdaiModel.getModelId();
    if (modelId == null) {
        return RestResult.genFailResult("模型ID不能为空");
    }
    GdaiModel model;
    try {
        //修复水平越权问题
        model = checkGdaiModel(user, modelId, true);
        //            model = gdaiModelService.selectById(modelId);
    } catch (Exception e) {
        log.info("根据ID查询模型信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(model);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.vo.Result
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiModelService gdaiModelService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为downloadModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadModel(Long modelId, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiModelServiceImpl.downloadModel params: [{}]", JSON.toJSONString(modelId));
    if (modelId == null) {
        return RestResult.genFailResult("模型ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //根据模型ID查询该模型存储路径，若不为空则去对应路径下载训练完模型
        //修复水平越权问题
        GdaiModel model = checkGdaiModel(user, modelId, true);
        //            GdaiModel model = gdaiModelService.selectById(modelId);
        //            if (model == null) {
        //                return RestResult.genFailResult("该模型信息不存在");
        //            }
        //获取算法保存路径
        String modelSavePath = model.getModelSavePath();
        if (StringUtils.isBlank(modelSavePath)) {
            return RestResult.genFailResult("模型保存路径为空");
        }
        String fileName = "model_" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(modelSavePath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModel
com.eshore.gdai.trainingcenter.service.GdaiModelService
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiModelService gdaiModelService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServiceImpl中有一个名为checkGdaiModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiModel checkGdaiModel(User user, Long modelId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiModel model = gdaiModelMapper.selectById(modelId);
    if (model == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(model.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(model.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(model.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return model;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModel
org.springframework.stereotype.Service
java.util.Set
### 类级别的变量
@Resource
private GdaiModelMapper gdaiModelMapper;
@Resource
private GdaiProjectService gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiModelServingAddVo gdaiModelServingAddVo) {
    log.info("GdaiModelServingServiceImpl.add params: [{}]", JSON.toJSONString(gdaiModelServingAddVo));
    GdaiModelServing gdaiModelServing = new GdaiModelServing();
    BeanUtils.copyProperties(gdaiModelServingAddVo, gdaiModelServing);
    Long projectId = gdaiModelServingAddVo.getProjectId();
    String servingName = gdaiModelServingAddVo.getServingName();
    String servingType = gdaiModelServingAddVo.getServingType();
    Long creatorId = gdaiModelServing.getCreatorId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (StringUtils.isBlank(servingName)) {
        return RestResult.genFailResult("部署服务名称不能为空");
    }
    if (StringUtils.isBlank(servingType)) {
        return RestResult.genFailResult("部署服务类型不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    try {
        gdaiModelServingMapper.insert(gdaiModelServing);
        Long servingId = gdaiModelServing.getServingId();
        gdaiModelServing.setServingId(servingId);
        gdaiModelServingAddVo.getGdaiModelDeploy().setServingId(servingId);
        //根据servingType选择部署资源池
        if ("1".equals(servingType)) {
            //使用本地资源池部署
            //修改状态为开始部署
            RestResult result = gdaiModelDeployService.add(gdaiModelServingAddVo.getGdaiModelDeploy());
            if (result != null && result.getSuccess() != 0) {
                throw new Exception(result.getMessage());
            }
        } else if ("2".equals(servingType)) {
            //使用多云管资源池部署
            RestResult restResult = gdaiModelServingService.addIcspDeployInfo(gdaiModelServingAddVo);
            if (restResult != null && restResult.getSuccess() != 0) {
                throw new Exception(restResult.getMessage());
            }
        } else {
            return RestResult.genFailResult("部署服务类型错误");
        }
    } catch (Exception e) {
        log.info("模型部署异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("模型部署异常" + e.getMessage());
    }
    return RestResult.genSuccessResult("开始部署", gdaiModelServing);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiModelServingService gdaiModelServingService;
@Resource
private GdaiModelDeployService gdaiModelDeployService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为replace的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult replace(GdaiModelServingAddVo gdaiModelServingAddVo) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.replace params: [{}]", JSON.toJSONString(gdaiModelServingAddVo));
    GdaiModelServing gdaiModelServing = gdaiModelServingMapper.selectById(gdaiModelServingAddVo.getServingId());
    if (gdaiModelServing == null) {
        return RestResult.genFailResult("部署服务不存在");
    }
    //更新字段
    gdaiModelServing.setServingDesc(gdaiModelServingAddVo.getServingDesc());
    gdaiModelServing.setServingName(gdaiModelServingAddVo.getServingName());
    gdaiModelServing.setShareFlag(gdaiModelServingAddVo.getShareFlag());
    try {
        //合并serviceUrl中的url
        JSONArray serviceUrlVo = JSONArray.parseArray(gdaiModelServingAddVo.getGdaiModelDeploy().getServiceUrl());
        if (serviceUrlVo != null && !serviceUrlVo.isEmpty()) {
            GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(gdaiModelServing.getServingId());
            JSONArray serviceUrl = JSONArray.parseArray(gdaiModelDeploy.getServiceUrl());
            for (int i = 0; i < serviceUrlVo.size(); i++) {
                if (StringUtils.isEmpty(serviceUrlVo.getJSONObject(i).getString("url"))) {
                    for (int j = 0; j < serviceUrl.size(); j++) {
                        if (Objects.equals(serviceUrlVo.getJSONObject(i).getString("port"), serviceUrl.getJSONObject(j).getString("port"))) {
                            serviceUrlVo.getJSONObject(i).put("url", serviceUrl.getJSONObject(j).getString("url"));
                        }
                    }
                }
            }
            gdaiModelServingAddVo.getGdaiModelDeploy().setServiceUrl(JSONObject.toJSONString(serviceUrlVo));
        }
        gdaiModelServingAddVo.getGdaiModelDeploy().setServingId(gdaiModelServing.getServingId());
        //修改状态为开始部署
        RestResult result = gdaiModelDeployService.replace(gdaiModelServingAddVo.getGdaiModelDeploy());
        if (!Objects.equals(result.getCode(), "200")) {
            throw new Exception(result.getMessage());
        }
        gdaiModelServingMapper.updateById(gdaiModelServing);
    } catch (Exception e) {
        log.info("模型服务部署异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("模型服务部署异常");
    }
    return RestResult.genSuccessResult("开始部署", gdaiModelServing);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Objects
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为rollback的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult rollback(Long servingId, Long gdaiModelDeployId) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.rollback params: [{}]", gdaiModelDeployId);
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    if (servingId == null) {
        return RestResult.genFailResult("部署服务ID不能为空");
    }
    //修复水平越权问题
    GdaiModelServing gdaiModelServing = checkGdaiModelServing(user, servingId, true);
    try {
        //当前deploy设成deleted
        GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        gdaiModelDeploy.setDeleted(true);
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        return gdaiModelDeployService.rollback(gdaiModelDeployId);
    } catch (Exception e) {
        log.info("模型回滚异常:", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("模型回滚异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//
public RestResult updateShareFlag(GdaiModelServing gdaiModelServing) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.update params: [{}]", JSON.toJSONString(gdaiModelServing));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    Long servingId = gdaiModelServing.getServingId();
    String shareFlag = gdaiModelServing.getShareFlag();
    if (servingId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    GdaiModelServing Serving = checkGdaiModelServing(user, servingId, false);
    GdaiModelServing modelServing = new GdaiModelServing();
    modelServing.setServingId(servingId);
    modelServing.setShareFlag(shareFlag);
    modelServing.setModifyTime(new Date());
    gdaiModelServingMapper.updateById(modelServing);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Autowired
private HttpServletRequest request;
/**
 * 多云管用户Id
 */
@Value("${icsp.userId}")
private String userId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//
public RestResult delete(GdaiModelServingVo gdaiModelServingVo) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    Long projectId = gdaiModelServingVo.getProjectId();
    Long servingId = gdaiModelServingVo.getServingId();
    //获取deploySource用于判断删除是哪方调用删除
    Integer deploySource = gdaiModelServingVo.getDeploySource();
    try {
        //根据servingId查询记录，获取servingType，根据servingType判断是删除本地部署记录还是多云管部署记录
        GdaiModelServing gdaiModelServing = gdaiModelServingMapper.selectById(servingId);
        if (gdaiModelServing == null) {
            return RestResult.genFailResult("该记录不存在");
        }
        String servingType = gdaiModelServing.getServingType();
        if ("1".equals(servingType)) {
            //删除本地资源池部署记录
            //删除当前的deploy
            GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
            if (gdaiModelDeploy == null) {
                //没有对应的deploy，直接删除serving记录
                //删除serving记录
                gdaiModelServingMapper.deleteById(servingId);
            } else {
                GdaiModelDeployVo gdaiModelDeployVo = new GdaiModelDeployVo();
                BeanUtils.copyProperties(gdaiModelDeploy, gdaiModelDeployVo);
                RestResult result = gdaiModelDeployService.delete(gdaiModelDeployVo);
                if (result != null && Objects.equals(result.getCode(), "200")) {
                    //删除历史的deploy
                    gdaiModelDeployMapper.deleteByServingId(servingId, projectId);
                    //删除serving记录
                    gdaiModelServingMapper.deleteById(servingId);
                } else if (result != null) {
                    throw new Exception(result.getMessage());
                } else {
                    throw new Exception("删除失败");
                }
            }
        } else if ("2".equals(servingType)) {
            //删除多云管部署记录
            RestResult restResult = gdaiModelServingService.deleteIcspDeployInfo(gdaiModelServingVo);
            if (restResult != null && restResult.getSuccess() != 0) {
                throw new Exception(restResult.getMessage());
            }
        } else {
            return RestResult.genFailResult("部署服务类型错误");
        }
        //根据deploySource判断是否是第三方删除记录，如果是第三方删除，删除成功之后调回流接口通知算法录入方修改算法列表的部署为待部署
        if (2 == deploySource) {
            FeignServiceHelper.reflowAlgorithmStatus(userClient, new GdaiModelDeploy("", servingId));
        }
        return RestResult.genSuccessResult("删除成功");
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        log.info("删除应用部署异常", e);
    }
    return RestResult.genFailResult("删除应用部署异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Objects
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelServingService gdaiModelServingService;
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为thirdPartyDelete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult thirdPartyDelete(GdaiModelServingVo gdaiModelServingVo) {
    log.info("GdaiModelServingServiceImpl.thirdPartyDelete params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    Long projectId = gdaiModelServingVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long servingId = gdaiModelServingVo.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    try {
        //根据servingId查询记录，获取servingType，根据servingType判断是删除本地部署记录还是多云管部署记录
        GdaiModelServing gdaiModelServing = gdaiModelServingMapper.selectById(servingId);
        if (gdaiModelServing == null) {
            return RestResult.genFailResult("该记录不存在");
        }
        String servingType = gdaiModelServing.getServingType();
        if ("1".equals(servingType)) {
            //删除本地资源池部署记录
            //删除当前的deploy
            GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
            if (gdaiModelDeploy == null) {
                //没有对应的deploy，直接删除serving记录
                //删除serving记录
                gdaiModelServingMapper.deleteById(servingId);
            } else {
                GdaiModelDeployVo gdaiModelDeployVo = new GdaiModelDeployVo();
                BeanUtils.copyProperties(gdaiModelDeploy, gdaiModelDeployVo);
                RestResult result = gdaiModelDeployService.delete(gdaiModelDeployVo);
                if (result != null && Objects.equals(result.getCode(), "200")) {
                    //删除历史的deploy
                    gdaiModelDeployMapper.deleteByServingId(servingId, projectId);
                    //删除serving记录
                    gdaiModelServingMapper.deleteById(servingId);
                } else if (result != null) {
                    throw new Exception(result.getMessage());
                } else {
                    throw new Exception("删除失败");
                }
            }
        } else if ("2".equals(servingType)) {
            //删除多云管部署记录
            RestResult restResult = gdaiModelServingService.deleteIcspDeployInfo(gdaiModelServingVo);
            if (restResult != null && restResult.getSuccess() != 0) {
                throw new Exception(restResult.getMessage());
            }
        } else {
            return RestResult.genFailResult("部署服务类型错误");
        }
        return RestResult.genSuccessResult("删除成功");
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        log.info("删除应用部署异常", e);
    }
    return RestResult.genFailResult("删除应用部署异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Objects
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelServingService gdaiModelServingService;
@Resource
private GdaiModelDeployService gdaiModelDeployService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为queryModelServing的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelServing(GdaiModelServingVo gdaiModelServingVo) {
    log.info("GdaiModelServingServiceImpl.queryModelServing params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    Long projectId = gdaiModelServingVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String ServingSource = gdaiModelServingVo.getServingType();
    String servingName = gdaiModelServingVo.getServingName();
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    Page<GdaiModelServing> gdaiModelServingPage = null;
    UiPage<GdaiModelServingVo> uiPage = new UiPage<>();
    List<GdaiModelServingVo> list = new ArrayList<>();
    EntityWrapper<GdaiModelServing> wrapper = new EntityWrapper<>();
    if (gdaiModelServingVo.getDeploySource() != null) {
        wrapper.eq("deploy_source", gdaiModelServingVo.getDeploySource());
    }
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员创建的任务
        wrapper.eq("project_id", projectId);
        if (StringUtils.isNotBlank(ServingSource)) {
            wrapper.eq("serving_type", ServingSource);
        }
        // 如果servingName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(servingName)) {
            wrapper.like("serving_name", servingName);
        }
        wrapper.orderDesc(desc);
    } else {
        wrapper.eq("project_id", projectId).andNew().eq("share_flag", "1").or().eq("creator_id", userId);
        // 如果servingName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(servingName)) {
            wrapper.like("serving_name", servingName);
        }
        wrapper.orderDesc(desc);
    }
    gdaiModelServingPage = gdaiModelServingService.selectPage(new Page<>(gdaiModelServingVo.getPageNumber(), gdaiModelServingVo.getPageCount()), wrapper);
    if (gdaiModelServingPage != null && gdaiModelServingPage.getRecords().size() > 0) {
        List<GdaiModelServing> records = gdaiModelServingPage.getRecords();
        for (GdaiModelServing gdaiModelServing : records) {
            gdaiModelServingVo = new GdaiModelServingVo();
            BeanUtils.copyProperties(gdaiModelServing, gdaiModelServingVo);
            Long creatorId = gdaiModelServing.getCreatorId();
            User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
            if (userInfo != null) {
                gdaiModelServingVo.setCreatorName(userInfo.getUsername());
            }
            GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(gdaiModelServing.getServingId());
            if (gdaiModelDeploy != null) {
                //deploy_id
                gdaiModelServingVo.setDeployId(gdaiModelDeploy.getDeployId());
                //status
                gdaiModelServingVo.setStatus(gdaiModelDeploy.getStatus());
                gdaiModelServingVo.setReplicas(gdaiModelDeploy.getReplicas());
                gdaiModelServingVo.setReadyReplicas(gdaiModelDeploy.getReadyReplicas());
            }
            list.add(gdaiModelServingVo);
        }
        uiPage.setTotal(gdaiModelServingPage.getTotal());
        uiPage.setPageSize(gdaiModelServingPage.getSize());
        uiPage.setPages(gdaiModelServingPage.getPages());
        uiPage.setPageNum(gdaiModelServingPage.getCurrent());
        uiPage.setList(list);
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiModelServingVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelServingService gdaiModelServingService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;
/**
 * 多云管用户Id
 */
@Value("${icsp.userId}")
private String userId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为queryModelDeployHistory的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelDeployHistory(GdaiModelServingVo gdaiModelServingVo) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.queryModelDeployHistory params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    Long projectId = gdaiModelServingVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long servingId = gdaiModelServingVo.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelServing gdaiModelServing = checkGdaiModelServing(user, servingId, true);
    List<String> desc = new ArrayList<>();
    desc.add("deploy_id");
    List<GdaiModelDeploy> gdaiModelDeploys = gdaiModelDeployMapper.selectList(new EntityWrapper<GdaiModelDeploy>().eq("serving_id", servingId).orderDesc(desc));
    if (gdaiModelDeploys != null && gdaiModelDeploys.size() > 0) {
        return RestResult.genSuccessResult(gdaiModelDeploys.subList(1, gdaiModelDeploys.size()));
    }
    return RestResult.genSuccessResult(new ArrayList<>());
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为queryModelServingById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryModelServingById(GdaiModelServing gdaiModelServing) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.queryModelServingById params: [{}]", JSON.toJSONString(gdaiModelServing));
    Long servingId = gdaiModelServing.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //根据ID查询该部署记录是否存在
    //修复水平越权问题
    GdaiModelServing modelServing = checkGdaiModelServing(user, servingId, true);
    GdaiModelServingDetailVo gdaiModelServingVo = new GdaiModelServingDetailVo();
    BeanUtils.copyProperties(modelServing, gdaiModelServingVo);
    GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
    if (deploy != null) {
        gdaiModelServingVo.setGdaiModelDeploy(deploy);
    }
    return RestResult.genSuccessResult(gdaiModelServingVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelServingDetailVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为thirdPartyQueryServingById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult thirdPartyQueryServingById(GdaiModelServing gdaiModelServing) {
    log.info("GdaiModelServingServiceImpl.thirdPartyQueryServingById params: [{}]", JSON.toJSONString(gdaiModelServing));
    Long servingId = gdaiModelServing.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("部署ID不能为空");
    }
    GdaiModelServing modelServing = gdaiModelServingMapper.selectById(servingId);
    if (modelServing == null) {
        return RestResult.genFailResult("该部署记录不存在");
    }
    GdaiModelServingDetailVo gdaiModelServingVo = new GdaiModelServingDetailVo();
    BeanUtils.copyProperties(modelServing, gdaiModelServingVo);
    GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
    if (deploy != null) {
        gdaiModelServingVo.setGdaiModelDeploy(deploy);
    }
    return RestResult.genSuccessResult(gdaiModelServingVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelServingDetailVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为thirdPartyQueryIcspInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult thirdPartyQueryIcspInfo(GdaiModelServing gdaiModelServing) {
    log.info("GdaiModelServingServiceImpl.thirdPartyQueryIcspInfo params: [{}]", JSON.toJSONString(gdaiModelServing));
    String servingType = gdaiModelServing.getServingType();
    String areaCode = gdaiModelServing.getAreaCode();
    String orderAlgorithmId = gdaiModelServing.getOrderAlgorithmId();
    if (StringUtils.isBlank(servingType)) {
        return RestResult.genFailResult("服务类型不能为空");
    }
    if (StringUtils.isBlank(areaCode)) {
        return RestResult.genFailResult("地区编码不能为空");
    }
    if (StringUtils.isBlank(orderAlgorithmId)) {
        return RestResult.genFailResult("订单算法ID不能为空");
    }
    try {
        //根据servingType、areaCode、orderAlgorithmId查询是否存在服务记录
        GdaiModelServing modelServing = gdaiModelServingMapper.selectOne(new GdaiModelServing(servingType, areaCode, orderAlgorithmId));
        if (modelServing == null) {
            //查询默认省中心节点该算法部署信息
            GdaiModelServing serving = gdaiModelServingMapper.selectOne(new GdaiModelServing(servingType, "93", orderAlgorithmId));
            if (serving == null) {
                return RestResult.genFailResult("多云管未在该地市节点和省中心节点部署该算法");
            } else {
                Long servingId = serving.getServingId();
                GdaiModelServingDetailVo gdaiModelServingVo = new GdaiModelServingDetailVo();
                BeanUtils.copyProperties(serving, gdaiModelServingVo);
                GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
                if (deploy == null) {
                    return RestResult.genFailResult("存在省中心节点Serving信息但未查询到部署信息：" + servingId);
                }
                gdaiModelServingVo.setGdaiModelDeploy(deploy);
                //如果该地区未部署该算法，返回默认省中心(areaCode=93)部署信息
                log.info("该地区多云管未部署该算法: [{}]", JSON.toJSONString(gdaiModelServingVo));
                return RestResult.genResult(0, "201", "该地区多云管未部署该算法", gdaiModelServingVo);
            }
        } else {
            //如果记录存在则返回部署信息
            Long servingId = modelServing.getServingId();
            GdaiModelServingDetailVo gdaiModelServingVo = new GdaiModelServingDetailVo();
            BeanUtils.copyProperties(modelServing, gdaiModelServingVo);
            GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
            if (deploy == null) {
                return RestResult.genFailResult("存在地市节点Serving信息但未查询到部署信息：" + servingId);
            }
            gdaiModelServingVo.setGdaiModelDeploy(deploy);
            gdaiModelServingVo.setServingId(servingId);
            //解析deploy信息获取taskCode(即新增时的taskReqId)
            String context = deploy.getContext();
            JSONObject jsonContext = JSON.parseObject(context);
            JSONObject icsp = jsonContext.getJSONObject("icsp");
            String taskCode = icsp.getString("taskReqId");
            gdaiModelServingVo.setTaskCode(taskCode);
            log.info("该地区多云管已部署该算法: [{}]", JSON.toJSONString(gdaiModelServingVo));
            return RestResult.genResult(0, "202", "该地区多云管已部署该算法", gdaiModelServingVo);
        }
    } catch (Exception e) {
        log.info("第三方查询是否有多云管部署记录异常:", e);
        return RestResult.genFailResult("第三方查询是否有多云管部署记录异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelServingDetailVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为startService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult startService(GdaiModelServingVo gdaiModelServingVo) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.startService params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    Long projectId = gdaiModelServingVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long servingId = gdaiModelServingVo.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelServing gdaiModelServing = checkGdaiModelServing(user, servingId, true);
    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
    if (gdaiModelDeploy == null) {
        return RestResult.genFailResult("记录不存在");
    }
    GdaiModelDeployVo gdaiModelDeployVo = new GdaiModelDeployVo();
    gdaiModelDeployVo.setDeployId(gdaiModelDeploy.getDeployId());
    gdaiModelDeployVo.setProjectId(gdaiModelDeploy.getProjectId());
    return gdaiModelDeployService.startService(gdaiModelDeployVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为stopService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult stopService(GdaiModelServingVo gdaiModelServingVo) throws TrainginCenterException {
    log.info("GdaiModelServingServiceImpl.stopService params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    Long projectId = gdaiModelServingVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    Long servingId = gdaiModelServingVo.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiModelServing gdaiModelServing = checkGdaiModelServing(user, servingId, true);
    GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
    if (gdaiModelDeploy == null) {
        return RestResult.genFailResult("记录不存在");
    }
    GdaiModelDeployVo gdaiModelDeployVo = new GdaiModelDeployVo();
    gdaiModelDeployVo.setDeployId(gdaiModelDeploy.getDeployId());
    gdaiModelDeployVo.setProjectId(gdaiModelDeploy.getProjectId());
    return gdaiModelDeployService.stopService(gdaiModelDeployVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为apiCheck的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult<Object> apiCheck(ApiCheckVo dto) {
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        //            GdaiModelServing gdaiModelServing = checkGdaiModelServing(user, servingId, true);
        Boolean isHttps = false;
        if (StringUtils.isNotEmpty(dto.getApiType()) && Objects.equals(dto.getApiType().toUpperCase(), "HTTPS")) {
            isHttps = true;
            RestResult.genFailResult("暂时不支持");
        }
        String apiAddr = dto.getApiAddr();
        String result = "";
        if (Objects.equals(dto.getApiMode().toUpperCase(), "GET")) {
            result = HttpUtils.doGet(apiAddr, dto.getHeaders(), dto.getQueryParams());
        } else if (Objects.equals(dto.getApiMode().toUpperCase(), "POST")) {
            result = HttpUtils.doPostJson(apiAddr, dto.getHeaders(), dto.getQueryParams(), dto.getBody());
        } else if (Objects.equals(dto.getApiMode().toUpperCase(), "PUT")) {
            return RestResult.genFailResult("暂时不支持");
        } else if (Objects.equals(dto.getApiMode().toUpperCase(), "PATCH")) {
            return RestResult.genFailResult("暂时不支持");
        } else if (Objects.equals(dto.getApiMode().toUpperCase(), "DELETE")) {
            return RestResult.genFailResult("暂时不支持");
        } else {
            return RestResult.genFailResult("无效的接口方式");
        }
        return RestResult.genSuccessResult(JSON.parseObject(result));
    } catch (Exception e) {
        return RestResult.genFailResult(e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.HttpUtils
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
org.apache.commons.lang3.StringUtils
java.util.Objects
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为addIcspDeployInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addIcspDeployInfo(GdaiModelServingAddVo gdaiModelServingAddVo) {
    log.info("GdaiModelServingServiceImpl.addIcspDeployInfo params: [{}]", JSON.toJSONString(gdaiModelServingAddVo));
    //调多云管资源池新增部署服务
    try {
        //1.拼装多云管部署参数
        JSONObject json = new JSONObject();
        String context = gdaiModelServingAddVo.getGdaiModelDeploy().getContext();
        JSONObject jsonContext = JSON.parseObject(context);
        //获取镜像URL
        String harborUrl = jsonContext.getString("image");
        String imageServerPort = "";
        //获取部署端口号（默认取第一个值）
        JSONArray servicesArray = (JSONArray) jsonContext.get("services");
        // 获取数组的第一个元素
        if (!servicesArray.isEmpty()) {
            imageServerPort = servicesArray.getString(0);
        }
        //获取内存大小
        String memory = jsonContext.getString("memory");
        //将memory转为整数并乘以1024转为MB单位
        long memoryLong = Long.parseLong(memory) * 1024;
        //获取core
        String core = jsonContext.getString("core");
        //获取processUnitType用来判断是否为GPU，并确定显卡张数
        String processUnitType = jsonContext.getString("processUnitType");
        String cardNumber;
        String architecture;
        if ("CPU".equalsIgnoreCase(processUnitType)) {
            cardNumber = "0";
            //获取cpu架构类型
            String algorithmCpu = jsonContext.getString("algorithmCpu");
            if ("X86".equalsIgnoreCase(algorithmCpu)) {
                architecture = "amd64";
            } else if ("ARM64".equalsIgnoreCase(algorithmCpu)) {
                architecture = "arm64";
            } else {
                architecture = "";
            }
        } else if ("GPU".equalsIgnoreCase(processUnitType)) {
            JSONObject gpuObject = jsonContext.getJSONObject("gpu");
            cardNumber = gpuObject.getString("cardNumber");
            architecture = "";
        } else {
            return RestResult.genFailResult("processUnitType参数错误");
        }
        //获取副本数
        String instances = jsonContext.getString("instances");
        //获取镜像名称
        String servingName = gdaiModelServingAddVo.getServingName();
        //获取镜像tag
        String imageTag = harborUrl.substring(harborUrl.lastIndexOf(":") + 1);
        //获取command和args并拼成一个字符串
        String command = jsonContext.getString("command");
        String args = jsonContext.getString("args");
        String commandArgs;
        if (command != null && !command.isEmpty()) {
            if (args != null && !args.isEmpty()) {
                commandArgs = command + " " + args;
            } else {
                commandArgs = command;
            }
        } else if (args != null && !args.isEmpty()) {
            commandArgs = args;
        } else {
            commandArgs = "";
        }
        JSONArray commandArgsArray = new JSONArray();
        if (commandArgs != null && !commandArgs.isEmpty()) {
            commandArgsArray.add(commandArgs);
        } else {
            commandArgsArray.add("");
        }
        //获取显卡类型
        String gpuType;
        gpuType = jsonContext.getString("algorithmGpu");
        if ("nvidia".equalsIgnoreCase(gpuType)) {
            gpuType = "NVIDIA";
        } else {
            gpuType = "HW";
        }
        //获取算法类型
        String taskDetailType = jsonContext.getString("algorithmType");
        //获取镜像部署节点所在地市码：默认93为省中点部署节点
        String areaCode = jsonContext.getString("areaCode");
        if (StringUtils.isBlank(areaCode)) {
            //为空说明部署在省中心资源池，不为空则为地市节点资源池
            areaCode = "93";
        }
        //获取项目编号
        String projectId = gdaiModelServingAddVo.getProjectId().toString();
        //根据projectId拼装成namespace
        String namespace = "gdai-" + projectId;
        // 组装resInfoDto
        JSONObject resInfoDto = new JSONObject();
        resInfoDto.put("harborUrl", harborUrl);
        resInfoDto.put("imageServerUrl", "/");
        resInfoDto.put("imageServerPort", imageServerPort);
        JSONObject resourceSpec = new JSONObject();
        //resourceSpec.put("disk", "20");
        resourceSpec.put("memory", memoryLong);
        resourceSpec.put("cpu", core);
        resourceSpec.put("gpu", cardNumber);
        //算网增加的GPU虚拟化参数，暂时不使用
        resourceSpec.put("divide", "false");
        resourceSpec.put("gpumem", "0");
        resourceSpec.put("gpucores", "0");
        resInfoDto.put("resourceSpec", resourceSpec);
        resInfoDto.put("instNum", instances);
        resInfoDto.put("imageName", servingName);
        resInfoDto.put("imageTag", imageTag);
        resInfoDto.put("commands", JSONArray.parseArray("[\"/bin/sh\",\"-c\"]"));
        resInfoDto.put("args", commandArgsArray);
        resInfoDto.put("useHarbor", false);
        resInfoDto.put("architecture", architecture);
        // 组装persistentVolumes（PVC挂载）
        //            JSONObject persistentVolumes = new JSONObject();
        //            resInfoDto.put("persistentVolumes", persistentVolumes);
        //
        //            // 组装configMaps
        //            JSONObject configMaps = new JSONObject();
        //            resInfoDto.put("configMaps", configMaps);
        //
        //            // 组装hostVolumes
        //            JSONObject hostVolumes = new JSONObject();
        //            resInfoDto.put("hostVolumes", hostVolumes);
        //
        //            // 组装memVolumes
        //            JSONObject memVolumes = new JSONObject();
        //            resInfoDto.put("memVolumes", memVolumes);
        json.put("resInfoDto", resInfoDto);
        // 组装taskInfoDto
        JSONObject taskInfoDto = new JSONObject();
        taskInfoDto.put("taskName", servingName);
        taskInfoDto.put("gpuType", gpuType);
        taskInfoDto.put("taskType", "k8s");
        taskInfoDto.put("taskDetailType", taskDetailType);
        taskInfoDto.put("taskDec", servingName);
        taskInfoDto.put("areaCode", areaCode);
        json.put("taskInfoDto", taskInfoDto);
        // 组装policyInfoDto
        JSONObject policyInfoDto = new JSONObject();
        policyInfoDto.put("policyCode", "randomRes");
        json.put("policyInfoDto", policyInfoDto);
        // 添加其他必填字段
        json.put("namespace", namespace);
        json.put("systemId", systemId);
        json.put("productCode", "10");
        json.put("operType", "add");
        json.put("taskReqId", createTaskReqId("1"));
        json.put("userId", userId);
        json.put("tenantId", tenantId);
        //2.调新增任务接口
        IcspResultVo icspResultVo = icspService.deployByImage(json);
        if (icspResultVo == null) {
            //新增任务失败
            return RestResult.genFailResult("新增多云管部署失败");
        }
        String code = icspResultVo.getCode();
        String message = icspResultVo.getMessage();
        if (!code.equals("0")) {
            //新增任务失败
            return RestResult.genFailResult("新增多云管部署失败：" + message);
        }
        //新增任务成功，构造部署表所需数据，插入数据库
        GdaiModelDeployVo modelDeploy = gdaiModelServingAddVo.getGdaiModelDeploy();
        GdaiModelDeploy gdaiModelDeploy = new GdaiModelDeploy();
        gdaiModelDeploy.setImageId(modelDeploy.getImageId());
        gdaiModelDeploy.setProjectId(modelDeploy.getProjectId());
        gdaiModelDeploy.setDeployName(gdaiModelServingAddVo.getServingName());
        gdaiModelDeploy.setHarborImageId(modelDeploy.getHarborImageId());
        gdaiModelDeploy.setTrainId(modelDeploy.getTrainId());
        gdaiModelDeploy.setPubYmlContent(modelDeploy.getPubYmlContent());
        //部署状态:S2C-部署中
        gdaiModelDeploy.setStatus("S2C");
        gdaiModelDeploy.setPubCntrMsg(modelDeploy.getPubCntrMsg());
        gdaiModelDeploy.setPubNamespaceName("gdai-" + modelDeploy.getProjectId());
        gdaiModelDeploy.setPubDeploymentName(modelDeploy.getPubDeploymentName());
        gdaiModelDeploy.setPubServiceName(modelDeploy.getPubServiceName());
        gdaiModelDeploy.setPubPodLabelSelector(modelDeploy.getPubPodLabelSelector());
        //部署来源:2-第三方
        gdaiModelDeploy.setDeploySource("2");
        gdaiModelDeploy.setShareFlag(modelDeploy.getShareFlag());
        gdaiModelDeploy.setRemarks(gdaiModelServingAddVo.getServingDesc());
        gdaiModelDeploy.setCreatorId(modelDeploy.getCreatorId());
        gdaiModelDeploy.setModifierId(modelDeploy.getModifierId());
        Date date = new Date();
        gdaiModelDeploy.setCreateTime(date);
        gdaiModelDeploy.setModifyTime(date);
        gdaiModelDeploy.setServingId(modelDeploy.getServingId());
        gdaiModelDeploy.setDeleted(false);
        gdaiModelDeploy.setModelId(modelDeploy.getModelId());
        //context大字段中既保留原数据，也保留新拼接的json串
        jsonContext.put("icsp", json);
        gdaiModelDeploy.setContext(jsonContext.toJSONString());
        gdaiModelDeploy.setServiceUrl(modelDeploy.getServiceUrl());
        gdaiModelDeploy.setEnvironmentId(modelDeploy.getEnvironmentId());
        gdaiModelDeploy.setAlgorithmId(modelDeploy.getAlgorithmId());
        //不使用字段，以后删除
        gdaiModelDeploy.setPubUrl("");
        gdaiModelDeploy.setCommandAndArgs("");
        gdaiModelDeploy.setGpuSize("");
        gdaiModelDeploy.setCore("0");
        gdaiModelDeploy.setMemorySize("");
        gdaiModelDeploy.setPubYmlContent("");
        gdaiModelDeploy.setPubCntrMsg("");
        log.info("新增多云管部署任务成功，构造部署表所需数据:[{}]", JSON.toJSONString(gdaiModelDeploy));
        gdaiModelDeployMapper.insert(gdaiModelDeploy);
    } catch (Exception e) {
        log.info("新增多云管部署异常:", e);
        return RestResult.genFailResult("新增多云管部署异常");
    }
    return RestResult.genSuccessResult("新增多云管部署任务开始");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private IcspService icspService;
/**
 * 多云管系统ID
 */
@Value("${icsp.systemId}")
private String systemId;
/**
 * 多云管用户Id
 */
@Value("${icsp.userId}")
private String userId;
/**
 * 多云管租户Id
 */
@Value("${icsp.tenantId}")
private String tenantId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为deleteIcspDeployInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteIcspDeployInfo(GdaiModelServingVo gdaiModelServingVo) {
    log.info("GdaiModelServingServiceImpl.deleteIcspDeployInfo params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    Long servingId = gdaiModelServingVo.getServingId();
    try {
        GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        if (gdaiModelDeploy == null) {
            //没有对应的deploy，直接删除serving记录
            //删除serving记录
            gdaiModelServingMapper.deleteById(servingId);
        } else {
            //解析deploy信息获取taskCode(即新增时的taskReqId)
            String context = gdaiModelDeploy.getContext();
            JSONObject jsonContext = JSON.parseObject(context);
            JSONObject icsp = jsonContext.getJSONObject("icsp");
            //taskCode是新增部署时的taskReqId
            String taskCode = icsp.getString("taskReqId");
            String taskReqId = createTaskReqId("3");
            //调用多云管删除接口
            IcspResultVo icspResultVo = icspService.deleteTask2(taskCode, taskReqId);
            if (icspResultVo == null) {
                //删除任务失败
                return RestResult.genFailResult("调用多云管删除失败");
            }
            String code = icspResultVo.getCode();
            String message = icspResultVo.getMessage();
            if (!code.equals("0")) {
                //删除任务失败
                return RestResult.genFailResult("调用多云管删除失败：" + message);
            }
            //多云管删除任务成功，删除deploy记录
            GdaiModelDeployVo gdaiModelDeployVo = new GdaiModelDeployVo();
            BeanUtils.copyProperties(gdaiModelDeploy, gdaiModelDeployVo);
            RestResult result = gdaiModelDeployService.delete(gdaiModelDeployVo);
            if (result != null && Objects.equals(result.getCode(), "200")) {
                //删除serving记录
                gdaiModelServingMapper.deleteById(servingId);
            } else if (result != null) {
                return RestResult.genFailResult("删除部署信息失败：" + result.getMessage());
            } else {
                return RestResult.genFailResult("删除部署信息失败");
            }
        }
    } catch (Exception e) {
        log.info("删除多云管部署信息异常:", e);
        return RestResult.genFailResult("删除多云管部署信息异常");
    }
    return RestResult.genSuccessResult("删除多云管部署信息成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.service.GdaiModelServingService
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Objects
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Resource
private IcspService icspService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为checkGdaiModelServing的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//查询 修改 true   删除 false
 GdaiModelServing checkGdaiModelServing(User user, Long gdaiModelServingId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiModelServing gdaiModelServing = gdaiModelServingMapper.selectById(gdaiModelServingId);
    if (gdaiModelServing == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiModelServing.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(gdaiModelServing.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(gdaiModelServing.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return gdaiModelServing;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
org.springframework.stereotype.Service
java.util.Set
### 类级别的变量
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
/**
 * 多云管用户Id
 */
@Value("${icsp.userId}")
private String userId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiModelServingServiceImpl中有一个名为createTaskReqId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 生成任务单号
     *
     * @param orderOperation
     * @return
     */
private String createTaskReqId(String orderOperation) {
    String dateToStr = DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
    if ("1".equals(orderOperation)) {
        //新增任务单号
        dateToStr = "10" + dateToStr;
    } else if ("2".equals(orderOperation)) {
        //修改任务单号
        dateToStr = "20" + dateToStr;
    } else if ("3".equals(orderOperation)) {
        //删除任务单号
        dateToStr = "30" + dateToStr;
    } else if ("4".equals(orderOperation)) {
        //扩缩容任务单号
        dateToStr = "40" + dateToStr;
    }
    return dateToStr;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.DateUtil
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiNodeInfo gdaiNodeInfo) {
    log.info("GdaiNodeInfoServiceImpl.add params: [{}]", JSON.toJSONString(gdaiNodeInfo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    String nodeNames = gdaiNodeInfo.getNodeNames();
    String nodeIp = gdaiNodeInfo.getNodeIp();
    Long clusterId = gdaiNodeInfo.getClusterId();
    Long nodeCoreNumber = gdaiNodeInfo.getNodeCoreNumber();
    Long nodeCpuSize = gdaiNodeInfo.getNodeCpuSize();
    Long nodeGpuSize = gdaiNodeInfo.getNodeGpuSize();
    Long nodeDiskSize = gdaiNodeInfo.getNodeDiskSize();
    if (StringUtils.isBlank(nodeNames)) {
        return RestResult.genFailResult("节点名称不能为空");
    }
    if (StringUtils.isBlank(nodeIp)) {
        return RestResult.genFailResult("节点IP不能为空");
    }
    if (clusterId == null) {
        return RestResult.genFailResult("集群ID不能为空");
    }
    if (nodeCoreNumber == null) {
        return RestResult.genFailResult("节点总核数不能为空");
    }
    if (nodeCpuSize == null) {
        return RestResult.genFailResult("节点总CPU大小不能为空");
    }
    if (nodeGpuSize == null) {
        return RestResult.genFailResult("节点总GPU大小不能为空");
    }
    if (nodeDiskSize == null) {
        return RestResult.genFailResult("节点总磁盘大小不能为空");
    }
    try {
        //查询是否存在同名集群
        GdaiNodeInfo nodeInfo = gdaiNodeInfoMapper.selectOne(new GdaiNodeInfo(nodeNames, clusterId));
        if (nodeInfo != null) {
            return RestResult.genFailResult("该集群下已存在同名节点");
        }
        Date curDate = new Date();
        gdaiNodeInfo.setCreatorId(userId);
        gdaiNodeInfo.setCreateTime(curDate);
        gdaiNodeInfo.setModifyTime(curDate);
        gdaiNodeInfoMapper.insert(gdaiNodeInfo);
    } catch (Exception e) {
        log.info("新增节点信息异常", e);
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiNodeInfo gdaiNodeInfo) throws TrainginCenterException {
    log.info("GdaiNodeInfoServiceImpl.update params: [{}]", JSON.toJSONString(gdaiNodeInfo));
    Long nodeId = gdaiNodeInfo.getNodeId();
    if (nodeId == null) {
        return RestResult.genFailResult("节点ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiNodeInfo nodeInfo = checkGdaiNodeInfo(user, nodeId);
    try {
        BeanUtils.copyProperties(gdaiNodeInfo, nodeInfo);
        Date curDate = new Date();
        nodeInfo.setModifyTime(curDate);
        nodeInfo.setModifierId(user.getId());
        gdaiNodeInfoMapper.updateById(nodeInfo);
    } catch (Exception e) {
        log.info("修改节点信息异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiNodeInfo gdaiNodeInfo) throws TrainginCenterException {
    log.info("GdaiNodeInfoServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiNodeInfo));
    Long nodeId = gdaiNodeInfo.getNodeId();
    if (nodeId == null) {
        return RestResult.genFailResult("节点ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    gdaiNodeInfo = checkGdaiNodeInfo(user, nodeId);
    try {
        //            //检查该节点是否存在
        //            GdaiNodeInfo nodeInfo = gdaiNodeInfoMapper.selectById(nodeId);
        //            if (nodeInfo == null) {
        //                return RestResult.genFailResult("该节点不存在");
        //            }
        gdaiNodeInfoMapper.deleteById(nodeId);
    } catch (Exception e) {
        log.info("删除节点信息异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为queryNodeList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryNodeList(GdaiNodeInfoVo gdaiNodeInfoVo) {
    log.info("GdaiNodeInfoServiceImpl.queryNodeList params: [{}]", JSON.toJSONString(gdaiNodeInfoVo));
    Long clusterId = gdaiNodeInfoVo.getClusterId();
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    List<GdaiNodeInfoVo> list = new ArrayList<>();
    UiPage<GdaiNodeInfoVo> uiPage = new UiPage<>();
    try {
        Page<GdaiNodeInfo> gdaiNodeInfoPage = gdaiNodeInfoService.selectPage(new Page<>(gdaiNodeInfoVo.getPageNumber(), gdaiNodeInfoVo.getPageCount()), new EntityWrapper<GdaiNodeInfo>().eq(clusterId != null, "cluster_id", clusterId).orderDesc(desc));
        if (gdaiNodeInfoPage != null && gdaiNodeInfoPage.getRecords().size() > 0) {
            List<GdaiNodeInfo> records = gdaiNodeInfoPage.getRecords();
            for (GdaiNodeInfo gdaiNodeInfo : records) {
                gdaiNodeInfoVo = new GdaiNodeInfoVo();
                BeanUtils.copyProperties(gdaiNodeInfo, gdaiNodeInfoVo);
                list.add(gdaiNodeInfoVo);
            }
            uiPage.setTotal(gdaiNodeInfoPage.getTotal());
            uiPage.setPageSize(gdaiNodeInfoPage.getSize());
            uiPage.setPages(gdaiNodeInfoPage.getPages());
            uiPage.setPageNum(gdaiNodeInfoPage.getCurrent());
            uiPage.setList(list);
        }
    } catch (Exception e) {
        log.info("查询节点列表异常", e);
        return RestResult.genFailResult("查询节点列表异常");
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
com.eshore.gdai.trainingcenter.vo.GdaiNodeInfoVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为queryNodeAllRes的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryNodeAllRes(GdaiNodeInfoVo gdaiNodeInfoVo) {
    log.info("GdaiNodeInfoServiceImpl.queryNodeAllRes params: [{}]", JSON.toJSONString(gdaiNodeInfoVo));
    Long clusterId = gdaiNodeInfoVo.getClusterId();
    if (clusterId == null) {
        return RestResult.genFailResult("集群ID不能为空");
    }
    try {
        Long allNodeCoreNumber = gdaiNodeInfoMapper.getAllNodeCoreNumber(clusterId);
        Long allNodeCpuSize = gdaiNodeInfoMapper.getAllNodeCpuSize(clusterId);
        Long allNodeGpuSize = gdaiNodeInfoMapper.getAllNodeGpuSize(clusterId);
        Long allNodeDiskSize = gdaiNodeInfoMapper.getAllNodeDiskSize(clusterId);
        Long allUsedCoreNumber = gdaiNodeInfoMapper.getAllUsedCoreNumber(clusterId);
        Long allUsedCpuSize = gdaiNodeInfoMapper.getAllUsedCpuSize(clusterId);
        Long allUsedGpuSize = gdaiNodeInfoMapper.getAllUsedGpuSize(clusterId);
        Long allUsedDiskSize = gdaiNodeInfoMapper.getAllUsedDiskSize(clusterId);
        Long allDevUsedCoreNumber = gdaiNodeInfoMapper.getAllDevUsedCoreNumber(clusterId);
        Long allDevUsedCpuSize = gdaiNodeInfoMapper.getAllDevUsedCpuSize(clusterId);
        Long allDevUsedGpuSize = gdaiNodeInfoMapper.getAllDevUsedGpuSize(clusterId);
        Long allDevUsedDiskSize = gdaiNodeInfoMapper.getAllDevUsedDiskSize(clusterId);
        Long allTrainUsedCoreNumber = gdaiNodeInfoMapper.getAllTrainUsedCoreNumber(clusterId);
        Long allTrainUsedCpuSize = gdaiNodeInfoMapper.getAllTrainUsedCpuSize(clusterId);
        Long allTrainUsedGpuSize = gdaiNodeInfoMapper.getAllTrainUsedGpuSize(clusterId);
        Long allTrainUsedDiskSize = gdaiNodeInfoMapper.getAllTrainUsedDiskSize(clusterId);
        Long allDeployUsedCoreNumber = gdaiNodeInfoMapper.getAllDeployUsedCoreNumber(clusterId);
        Long allDeployUsedCpuSize = gdaiNodeInfoMapper.getAllDeployUsedCpuSize(clusterId);
        Long allDeployUsedGpuSize = gdaiNodeInfoMapper.getAllDeployUsedGpuSize(clusterId);
        Long allDeployUsedDiskSize = gdaiNodeInfoMapper.getAllDeployUsedDiskSize(clusterId);
        Long allSystemUsedCoreNumber = gdaiNodeInfoMapper.getAllSystemUsedCoreNumber(clusterId);
        Long allSystemUsedCpuSize = gdaiNodeInfoMapper.getAllSystemUsedCpuSize(clusterId);
        Long allSystemUsedGpuSize = gdaiNodeInfoMapper.getAllSystemUsedGpuSize(clusterId);
        Long allSystemUsedDiskSize = gdaiNodeInfoMapper.getAllSystemUsedDiskSize(clusterId);
        gdaiNodeInfoVo.setAllNodeCoreNumber(allNodeCoreNumber);
        gdaiNodeInfoVo.setAllNodeCpuSize(allNodeCpuSize);
        gdaiNodeInfoVo.setAllNodeGpuSize(allNodeGpuSize);
        gdaiNodeInfoVo.setAllNodeDiskSize(allNodeDiskSize);
        gdaiNodeInfoVo.setAllUsedCoreNumber(allUsedCoreNumber);
        gdaiNodeInfoVo.setAllUsedCpuSize(allUsedCpuSize);
        gdaiNodeInfoVo.setAllUsedGpuSize(allUsedGpuSize);
        gdaiNodeInfoVo.setAllUsedDiskSize(allUsedDiskSize);
        gdaiNodeInfoVo.setAllDevUsedCoreNumber(allDevUsedCoreNumber);
        gdaiNodeInfoVo.setAllDevUsedCpuSize(allDevUsedCpuSize);
        gdaiNodeInfoVo.setAllDevUsedGpuSize(allDevUsedGpuSize);
        gdaiNodeInfoVo.setAllDevUsedDiskSize(allDevUsedDiskSize);
        gdaiNodeInfoVo.setAllTrainUsedCoreNumber(allTrainUsedCoreNumber);
        gdaiNodeInfoVo.setAllTrainUsedCpuSize(allTrainUsedCpuSize);
        gdaiNodeInfoVo.setAllTrainUsedGpuSize(allTrainUsedGpuSize);
        gdaiNodeInfoVo.setAllTrainUsedDiskSize(allTrainUsedDiskSize);
        gdaiNodeInfoVo.setAllDeployUsedCoreNumber(allDeployUsedCoreNumber);
        gdaiNodeInfoVo.setAllDeployUsedCpuSize(allDeployUsedCpuSize);
        gdaiNodeInfoVo.setAllDeployUsedGpuSize(allDeployUsedGpuSize);
        gdaiNodeInfoVo.setAllDeployUsedDiskSize(allDeployUsedDiskSize);
        gdaiNodeInfoVo.setAllSystemUsedCoreNumber(allSystemUsedCoreNumber);
        gdaiNodeInfoVo.setAllSystemUsedCpuSize(allSystemUsedCpuSize);
        gdaiNodeInfoVo.setAllSystemUsedGpuSize(allSystemUsedGpuSize);
        gdaiNodeInfoVo.setAllSystemUsedDiskSize(allSystemUsedDiskSize);
    } catch (Exception e) {
        log.info("查询多个节点汇总信息异常", e);
        return RestResult.genFailResult("查询多个节点汇总信息异常");
    }
    return RestResult.genSuccessResult(gdaiNodeInfoVo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为queryNodeInfoById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryNodeInfoById(GdaiNodeInfo gdaiNodeInfo) {
    log.info("GdaiNodeInfoServiceImpl.queryNodeInfoById params: [{}]", JSON.toJSONString(gdaiNodeInfo));
    Long nodeId = gdaiNodeInfo.getNodeId();
    if (nodeId == null) {
        return RestResult.genFailResult("节点ID不能为空");
    }
    GdaiNodeInfo nodeInfo;
    try {
        nodeInfo = gdaiNodeInfoService.selectById(nodeId);
    } catch (Exception e) {
        log.info("查询节点信息异常", e);
        return RestResult.genFailResult("查询节点信息异常");
    }
    return RestResult.genSuccessResult(nodeInfo);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiNodeInfoService gdaiNodeInfoService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为syncNodeResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult syncNodeResource(Long nodeId) throws Exception {
    log.info("GdaiNodeInfoServiceImpl.syncNodeResource params: [{}]", nodeId);
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiNodeInfo nodeInfo = checkGdaiNodeInfo(user, nodeId);
    GdaiClusterInfo clusterInfo = gdaiClusterInfoMapper.selectById(nodeInfo.getClusterId());
    try {
        updateNodeResource(clusterInfo.getClusterName(), nodeInfo.getNodeIp(), user.getId());
    } catch (Exception e) {
        log.info("同步节点信息异常", e);
        return RestResult.genFailResult("同步节点信息异常");
    }
    return RestResult.genSuccessResult("同步节点信息成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.stereotype.Service
javax.annotation.Resource
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为updateNodeResourceByIp的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void updateNodeResourceByIp(String clusterName, String nodeIp) throws Exception {
    try {
        updateNodeResource(clusterName, nodeIp, null);
    } catch (Exception e) {
        log.error("更新节点资源失败", e);
    }
}
### 类导入的包
javax.annotation.Resource
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为updateNodeResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public synchronized void updateNodeResource(String clusterName, String nodeIp, Long userId) throws Exception {
    log.info("GdaiNodeInfoServiceImpl.updateNodeResource params: [{},{},{}]", clusterName, nodeIp, userId);
    try {
        GdaiNodeInfo gdaiNode = gdaiNodeInfoMapper.selectForUpdate(nodeIp);
        if (gdaiNode == null) {
            throw new TrainginCenterException("该项目不存在");
        }
        NodeResourceInfoVo resourceInfo = nodeService.countNodeResourceInfo("", nodeIp);
        if (resourceInfo != null) {
            gdaiNode.setNodeCoreNumber(resourceInfo.getCpu());
            gdaiNode.setNodeCpuSize(resourceInfo.getMemory() * 1024);
            gdaiNode.setNodeGpuSize(resourceInfo.getGpuMemory());
            // 设置开发占用
            if (resourceInfo.getBizUsed() != null && resourceInfo.getBizUsed().get("dev_model") != null) {
                gdaiNode.setDevUsedCoreNumber(resourceInfo.getBizUsed().get("dev_model").getCpu());
                gdaiNode.setDevUsedCpuSize(resourceInfo.getBizUsed().get("dev_model").getMemory() * 1024);
                gdaiNode.setDevUsedGpuSize(resourceInfo.getBizUsed().get("dev_model").getGpuMemory());
            } else {
                gdaiNode.setDevUsedCoreNumber(0L);
                gdaiNode.setDevUsedCpuSize(0L);
                gdaiNode.setDevUsedGpuSize(0L);
            }
            // 设置训练占用
            if (resourceInfo.getBizUsed() != null && resourceInfo.getBizUsed().get("train_model") != null) {
                gdaiNode.setTrainUsedCoreNumber(resourceInfo.getBizUsed().get("train_model").getCpu());
                gdaiNode.setTrainUsedCpuSize(resourceInfo.getBizUsed().get("train_model").getMemory() * 1024);
                gdaiNode.setTrainUsedGpuSize(resourceInfo.getBizUsed().get("train_model").getGpuMemory());
            } else {
                gdaiNode.setTrainUsedCoreNumber(0L);
                gdaiNode.setTrainUsedCpuSize(0L);
                gdaiNode.setTrainUsedGpuSize(0L);
            }
            // 设置部署占用
            if (resourceInfo.getBizUsed() != null && resourceInfo.getBizUsed().get("deploy_model") != null) {
                gdaiNode.setDeployUsedCoreNumber(resourceInfo.getBizUsed().get("deploy_model").getCpu());
                gdaiNode.setDeployUsedCpuSize(resourceInfo.getBizUsed().get("deploy_model").getMemory() * 1024);
                gdaiNode.setDeployUsedGpuSize(resourceInfo.getBizUsed().get("deploy_model").getGpuMemory());
            } else {
                gdaiNode.setDeployUsedCoreNumber(0L);
                gdaiNode.setDeployUsedCpuSize(0L);
                gdaiNode.setDeployUsedGpuSize(0L);
            }
            // 设置系统占用
            if (resourceInfo.getBizUsed() != null && resourceInfo.getBizUsed().get("unknown") != null) {
                gdaiNode.setSystemUsedCoreNumber(resourceInfo.getBizUsed().get("unknown").getCpu());
                gdaiNode.setSystemUsedCpuSize(resourceInfo.getBizUsed().get("unknown").getMemory() * 1024);
                gdaiNode.setSystemUsedGpuSize(resourceInfo.getBizUsed().get("unknown").getGpuMemory());
            } else {
                gdaiNode.setSystemUsedCoreNumber(0L);
                gdaiNode.setSystemUsedCpuSize(0L);
                gdaiNode.setSystemUsedGpuSize(0L);
            }
            gdaiNode.setUsedCoreNumber(gdaiNode.getDevUsedCoreNumber() + gdaiNode.getTrainUsedCoreNumber() + gdaiNode.getDeployUsedCoreNumber() + gdaiNode.getSystemUsedCoreNumber());
            gdaiNode.setUsedCpuSize(gdaiNode.getDevUsedCpuSize() + gdaiNode.getTrainUsedCpuSize() + gdaiNode.getDeployUsedCpuSize() + gdaiNode.getSystemUsedCpuSize());
            gdaiNode.setUsedGpuSize(gdaiNode.getDevUsedGpuSize() + gdaiNode.getTrainUsedGpuSize() + gdaiNode.getDeployUsedGpuSize() + gdaiNode.getSystemUsedGpuSize());
        }
        Date curDate = new Date();
        gdaiNode.setModifyTime(curDate);
        if (userId != null) {
            gdaiNode.setModifierId(userId);
        }
        gdaiNodeInfoMapper.updateById(gdaiNode);
    } catch (Exception e) {
        throw new TrainginCenterException("更新节点资源异常" + e.getMessage());
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.k8s.domain.vo.NodeResourceInfoVo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Date
### 类级别的变量
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private NodeService nodeService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为getNodeGpuInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getNodeGpuInfo(Long nodeId, Long time) throws TrainginCenterException {
    log.info("GdaiNodeInfoServiceImpl.getNodeGpuInfo params: [{}]", nodeId);
    if (nodeId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiNodeInfo nodeInfo = checkGdaiNodeInfo(user, nodeId);
    GdaiClusterInfo clusterInfo = gdaiClusterInfoMapper.selectById(nodeInfo.getClusterId());
    try {
        return RestResult.genSuccessResult(metricsService.getNodeGpuInfo(nodeInfo.getNodeIp(), time));
    } catch (Exception e) {
        log.info("查询节点GPU信息异常", e);
        return RestResult.genFailResult("查询节点GPU信息异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiClusterInfo
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private MetricsService metricsService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为getNodeGpuContainerInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getNodeGpuContainerInfo(Long nodeId, String gpuName, Long time) throws TrainginCenterException {
    log.info("GdaiNodeInfoServiceImpl.getNodeGpuContainerInfo params: [{}]", nodeId);
    if (nodeId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiNodeInfo nodeInfo = checkGdaiNodeInfo(user, nodeId);
    try {
        return RestResult.genSuccessResult(metricsService.getNodeGpuContainerInfo(nodeInfo.getNodeIp(), gpuName, time));
    } catch (Exception e) {
        log.info("查询节点GPU信息异常", e);
        return RestResult.genFailResult("查询节点GPU信息异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
com.eshore.gdai.trainingcenter.service.GdaiNodeInfoService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private MetricsService metricsService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为queryNodeMetrics的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryNodeMetrics(Long nodeId, String gpuName, String queryParams, Long startTime, Long endTime, Integer step) throws TrainginCenterException {
    if (nodeId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiNodeInfo nodeInfo = checkGdaiNodeInfo(user, nodeId);
    try {
        String dockerDataPath = "/data";
        JSONObject content = JSONObject.parseObject(nodeInfo.getContent());
        if (content != null && StringUtils.isNotBlank(content.getString("dockerDataPath"))) {
            dockerDataPath = content.getString("dockerDataPath");
        }
        return RestResult.genSuccessResult(metricsService.getMetrics(queryParams, startTime, endTime, step, nodeInfo.getNodeIp(), gpuName, dockerDataPath, ""));
    } catch (Exception e) {
        return RestResult.genFailResult(e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private MetricsService metricsService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiNodeInfoServiceImpl中有一个名为checkGdaiNodeInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiNodeInfo checkGdaiNodeInfo(User user, Long nodeId) throws TrainginCenterException {
    GdaiNodeInfo gdaiNodeInfo = gdaiNodeInfoMapper.selectById(nodeId);
    if (gdaiNodeInfo == null) {
        throw new TrainginCenterException("记录不存在");
    } else {
        //判断登录用户角色
        //运营管理员角色
        boolean operAdminRole = SessionUtils.isOperAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(operAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(gdaiNodeInfo.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return gdaiNodeInfo;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiNodeInfo
### 类级别的变量
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为queryPodList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryPodList(GdaiPodVo gdaiPodVo) {
    if (gdaiPodVo.getBizId() == null) {
        return RestResult.genFailResult("业务ID不能为空");
    }
    if (StringUtils.isEmpty(gdaiPodVo.getBizType())) {
        return RestResult.genFailResult("业务类型不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        List<GdaiPod> podList = gdaiPodMapper.selectList(new EntityWrapper<GdaiPod>().eq("biz_id", gdaiPodVo.getBizId()).eq("biz_type", gdaiPodVo.getBizType()));
        List<GdaiPodVo> podVoList = new ArrayList<>();
        for (GdaiPod pod : podList) {
            GdaiPodVo podVo = new GdaiPodVo();
            //                pod.setMessage("");
            try {
                if (StringUtils.isNotEmpty(pod.getContent())) {
                    JSONObject content = JSON.parseObject(pod.getContent());
                    podVo.setHostIP(content.getString("hostIP"));
                    if (content.getJSONArray("containerStatuses") != null && !content.getJSONArray("containerStatuses").isEmpty()) {
                        podVo.setRestartCount(content.getJSONArray("containerStatuses").getObject(0, JSONObject.class).getInteger("restartCount"));
                    }
                }
                podVo.setMetrics(k8sClientOperator.getPodMetric(pod.getNamespace(), pod.getName()));
            } catch (Exception e) {
                log.error("补充Pod信息异常", e);
            }
            BeanUtils.copyProperties(pod, podVo);
            podVoList.add(podVo);
        }
        return RestResult.genSuccessResult(podVoList);
    } catch (Exception e) {
        log.info("查询Pod列表异常", e);
        return RestResult.genFailResult("查询Pod列表异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.vo.GdaiPodVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiPodMapper gdaiPodMapper;
@Resource
private K8sClientOperator k8sClientOperator;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为queryPodById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryPodById(String id) {
    if (StringUtils.isEmpty(id)) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        GdaiPod pod = gdaiPodMapper.selectById(id);
        GdaiPodVo podVo = new GdaiPodVo();
        BeanUtils.copyProperties(pod, podVo);
        return RestResult.genSuccessResult(podVo);
    } catch (Exception e) {
        log.error("通过Id查询Pod异常", e);
        return RestResult.genFailResult("通过Id查询Pod异常");
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.vo.GdaiPodVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
### 类级别的变量
@Resource
private GdaiPodMapper gdaiPodMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为getPodMetrics的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getPodMetrics(String id) {
    if (StringUtils.isEmpty(id)) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题 TBD
    try {
        GdaiPod pod = gdaiPodMapper.selectById(id);
        return RestResult.genSuccessResult(k8sClientOperator.getPodMetric(pod.getNamespace(), pod.getName()));
    } catch (Exception e) {
        return RestResult.genFailResult(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiPod
org.apache.commons.lang3.StringUtils
### 类级别的变量
@Resource
private GdaiPodMapper gdaiPodMapper;
@Resource
private K8sClientOperator k8sClientOperator;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为queryPodMetrics的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryPodMetrics(String id, String queryParams, Long startTime, Long endTime, Integer step) {
    if (StringUtils.isEmpty(id)) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题 TBD
    try {
        GdaiPod pod = gdaiPodMapper.selectById(id);
        return RestResult.genSuccessResult(metricsService.getMetrics(queryParams, startTime, endTime, step, "", "", "", pod.getName()));
    } catch (Exception e) {
        return RestResult.genFailResult(e.getMessage());
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiPod
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiPodMapper gdaiPodMapper;
@Autowired
private MetricsService metricsService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为deletePod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void deletePod() {
    List<GdaiPod> gdaiPods = gdaiPodMapper.selectList(new EntityWrapper<>());
    for (GdaiPod gdaiPod : gdaiPods) {
        try {
            PodBo podBo = podService.get("", gdaiPod.getNamespace(), gdaiPod.getName());
            if (podBo == null) {
                gdaiPodMapper.deleteById(gdaiPod.getId());
            }
        } catch (Exception e) {
            log.error("查询Pod异常：{}", e.getMessage());
        }
    }
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiPodMapper gdaiPodMapper;
@Autowired
private PodService podService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为buildMessage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String buildMessage(String message, PodBo podBo) throws Exception {
    JSONObject object = new JSONObject();
    if (StringUtils.isNotEmpty(message)) {
        object = JSON.parseObject(message);
    }
    try {
        List<ContainerStatusBo> containerStatuses = podBo.getContainerStatuses();
        if (CollectionUtil.isNotEmpty(containerStatuses)) {
            ContainerState containerState = new ContainerState();
            if (containerStatuses.get(0).getRunning() != null) {
                containerState.setState(V1ContainerState.SERIALIZED_NAME_RUNNING);
            } else if (containerStatuses.get(0).getWaiting() != null) {
                containerState.setState(V1ContainerState.SERIALIZED_NAME_WAITING);
                containerState.setMessage(containerStatuses.get(0).getWaiting().getMessage());
                containerState.setReason(containerStatuses.get(0).getWaiting().getReason());
            } else if (containerStatuses.get(0).getTerminated() != null) {
                containerState.setState(V1ContainerState.SERIALIZED_NAME_TERMINATED);
                containerState.setMessage(containerStatuses.get(0).getTerminated().getMessage());
                containerState.setReason(containerStatuses.get(0).getTerminated().getReason());
            } else {
                containerState.setState("未知状态");
            }
            object.put("state", containerState);
        }
        List<Event> events = k8sClientOperator.getEvents(podBo.getNamespace(), podBo.getName());
        if (events != null && !events.isEmpty()) {
            object.put("event", events);
        }
    } catch (Exception e) {
        log.error("构建消息异常", e);
    }
    return object.toJSONString();
}
### 类导入的包
cn.hutool.core.collection.CollectionUtil
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.k8s.domain.bo.ContainerStatusBo
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.models.V1ContainerState
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为downloadLog的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadLog(String id, HttpServletResponse response) throws TrainginCenterException {
    log.info("GdaiModelDeployServiceImpl.downloadLog params: [{}]", id);
    if (StringUtils.isEmpty(id)) {
        return RestResult.genFailResult("ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        GdaiPod pod = gdaiPodMapper.selectById(id);
        String fileName = pod.getName() + "-" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        String podLogs = podService.readNamespacedPodLog("", pod.getNamespace(), pod.getName());
        String date = DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);
        String str = "[ " + date + " ]  " + podLogs;
        //设置response的header
        response.setContentType("text/plain;charset=utf-8");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".log");
        response.getOutputStream().write(str.getBytes());
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.util.DateUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiPodMapper gdaiPodMapper;
@Autowired
private PodService podService;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为queryIcspInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryIcspInfo(JSONObject json) {
    log.info("GdaiModelDeployServiceImpl.queryIcspInfo params: [{}]", JSON.toJSONString(json));
    try {
        //调查询接口的taskReqId，没有业务含义，以90开头
        String taskReqId = "90" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
        String taskCode = json.getString("taskCode");
        //调多云管查询接口
        IcspResultVo taskQueryResultVo = icspService.taskQuery(taskReqId, taskCode);
        log.info("多云管查询接口返回值:[{}]", JSON.toJSONString(taskQueryResultVo));
        if (taskQueryResultVo == null) {
            return RestResult.genFailResult("多云管查询接口返回空");
        }
        String code = taskQueryResultVo.getCode();
        String message = taskQueryResultVo.getMessage();
        if (code.equals("0")) {
            return RestResult.genSuccessResult("多云管查询接口正常返回", taskQueryResultVo);
        } else if (code.equals("-1")) {
            log.info("正在部署中，请10分钟后查询部署结果");
            return RestResult.genFailResult("多云管正在部署中，请10分钟后查询部署结果");
        } else {
            return RestResult.genFailResult("多云管查询接口返回失败：" + message);
        }
    } catch (Exception e) {
        log.info("多云管查询接口返回异常", e);
        return RestResult.genFailResult("多云管查询接口返回异常", e.getMessage());
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private IcspService icspService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为queryIcspPodList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryIcspPodList(GdaiPodVo gdaiPodVo) {
    log.info("GdaiModelDeployServiceImpl.queryIcspPodList params: [{}]", JSON.toJSONString(gdaiPodVo));
    Long servingId = gdaiPodVo.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("servingId不能为空");
    }
    try {
        //根据servingId查询当前部署信息
        GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        if (deploy == null) {
            return RestResult.genFailResult("部署信息为空");
        }
        //调查询接口的taskReqId，没有业务含义，以90开头
        String taskReqId = "90" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
        //获取任务新增部署时的taskReqId（taskCode）
        String context = deploy.getContext();
        JSONObject jsonContext = JSON.parseObject(context);
        JSONObject icsp = jsonContext.getJSONObject("icsp");
        String taskCode = icsp.getString("taskReqId");
        //调多云管查询接口
        IcspResultVo taskQueryResultVo = icspService.taskQuery(taskReqId, taskCode);
        log.info("多云管查询接口返回值:[{}]", JSON.toJSONString(taskQueryResultVo));
        if (taskQueryResultVo == null) {
            //调任务调度结果信息查询失败
            return RestResult.genFailResult("未查询到容器部署信息");
        }
        String code = taskQueryResultVo.getCode();
        String message = taskQueryResultVo.getMessage();
        if (code.equals("0")) {
            //查询成功，解析各个pod信息
            Object data = taskQueryResultVo.getData();
            JSONObject jsonObject = JSON.parseObject(data.toString());
            // 从data对象中获取podInfos字段，这是一个JSONArray
            JSONArray podInfos = jsonObject.getJSONArray("podInfos");
            //解析podInfos中每个对象信息封装到GdaiPodVo对象
            List<GdaiPodVo> podVoList = new ArrayList<>();
            for (int i = 0; i < podInfos.size(); i++) {
                JSONObject podInfo = podInfos.getJSONObject(i);
                GdaiPodVo podVo = new GdaiPodVo();
                MetricsVo metricsVo = new MetricsVo();
                String podName = podInfo.getString("podName");
                String nameSpace = podInfo.getString("nameSpace");
                String podState = podInfo.getString("podState");
                if (podState.equals("0")) {
                    podState = "未启动";
                } else if (podState.equals("1")) {
                    podState = "正在启动中";
                } else if (podState.equals("2")) {
                    podState = "运行中";
                } else if (podState.equals("4")) {
                    podState = "任务出错";
                } else if (podState.equals("5")) {
                    podState = "已删除";
                }
                String hostIp = podInfo.getString("hostIp");
                String podStartTime = podInfo.getString("podStartTime");
                String cpuNum = podInfo.getString("cpuNum");
                String cpuUsage = podInfo.getString("cpuUsage");
                String memSize = podInfo.getString("memSize");
                String memUsage = podInfo.getString("memUsage");
                String namespace = podInfo.getString("namespace");
                metricsVo.setNamespace(nameSpace);
                metricsVo.setPodName(podName);
                metricsVo.setNodeName(hostIp);
                metricsVo.setCpuRequestNumber(cpuNum);
                metricsVo.setCpuUsagePercent(Float.parseFloat(cpuUsage) * 100);
                metricsVo.setMemoryRequestNumber(StringUtils.isNotBlank(memSize) ? String.valueOf((int) Math.round(Double.parseDouble(memSize)) / 1024) : "0");
                metricsVo.setMemoryUsagePercent(Float.parseFloat(memUsage) * 100);
                metricsVo.setMemoryRequestFormat("Gi");
                podVo.setMetrics(metricsVo);
                podVo.setNamespace(nameSpace);
                podVo.setName(podName);
                podVo.setPhase(podState);
                podVo.setHostIP(hostIp);
                podVo.setNamespace(namespace);
                podVo.setTaskCode(taskCode);
                podVo.setCreateTime(DateUtil.parseStrToDate(podStartTime, DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
                podVoList.add(podVo);
            }
            return RestResult.genSuccessResult(podVoList);
        } else if (code.equals("-1")) {
            log.info("正在部署中，请10分钟后查询部署结果");
            return RestResult.genSuccessResult("服务尚在部署中,请稍后再试");
        } else {
            //调任务调度结果信息查询失败
            return RestResult.genFailResult("查询容器部署信息失败: [{}]", message);
        }
    } catch (Exception e) {
        log.info("查询pod列表异常", e);
        return RestResult.genFailResult("查询pod列表异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiPod
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.GdaiPodVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
com.eshore.gdai.trainingcenter.vo.pod.MetricsVo
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private IcspService icspService;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为queryIcspPodEvent的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryIcspPodEvent(GdaiPodVo gdaiPodVo) {
    log.info("GdaiModelDeployServiceImpl.queryIcspPodEvent params: [{}]", JSON.toJSONString(gdaiPodVo));
    Long servingId = gdaiPodVo.getServingId();
    if (servingId == null) {
        return RestResult.genFailResult("servingId不能为空");
    }
    try {
        //根据servingId查询当前部署信息
        GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
        if (deploy == null) {
            return RestResult.genFailResult("部署信息为空");
        }
        //调查询事件接口的taskReqId，没有业务含义，以80开头
        String taskReqId = "80" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
        //获取任务新增部署时的taskReqId（taskCode）
        String context = deploy.getContext();
        JSONObject jsonContext = JSON.parseObject(context);
        JSONObject icsp = jsonContext.getJSONObject("icsp");
        String taskCode = icsp.getString("taskReqId");
        //拼装参数调查询事件接口
        JSONObject body = new JSONObject();
        body.put("systemId", systemId);
        body.put("productCode", "10");
        body.put("eventType", "pod");
        body.put("taskReqId", taskReqId);
        body.put("taskCode", taskCode);
        body.put("clusterName", "");
        body.put("namespace", "");
        body.put("deploymentName", "");
        //调用查询事件接口
        IcspResultVo queryEventResultVo = icspService.queryEventByPod(body);
        log.info("多云管查询接口返回值:[{}]", JSON.toJSONString(queryEventResultVo));
        if (queryEventResultVo == null) {
            //调接口查询失败
            return RestResult.genFailResult("未查询到容器事件信息");
        }
        String code = queryEventResultVo.getCode();
        String message = queryEventResultVo.getMessage();
        if (code.equals("0")) {
            //查询成功，解析各个pod对应事件
            Object data = queryEventResultVo.getData();
            JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(data));
            return RestResult.genSuccessResult("查询成功", jsonObject);
        } else {
            return RestResult.genFailResult("查询容器部署事件失败: [{}]", message);
        }
    } catch (Exception e) {
        log.info("查询容器部署事件异常", e);
        return RestResult.genFailResult("查询容器部署事件异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.IcspResultVo
com.eshore.gdai.trainingcenter.vo.pod.Event
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private IcspService icspService;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Value("${icsp.systemId}")
private String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiPodServiceImpl中有一个名为queryIcspPodLog的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryIcspPodLog(GdaiPodVo gdaiPodVo) {
    log.info("GdaiModelDeployServiceImpl.queryIcspPodLog params: [{}]", JSON.toJSONString(gdaiPodVo));
    String name = gdaiPodVo.getName();
    String namespace = gdaiPodVo.getNamespace();
    String taskCode = gdaiPodVo.getTaskCode();
    if (StringUtils.isBlank(name)) {
        return RestResult.genFailResult("podName不能为空");
    }
    if (StringUtils.isBlank(namespace)) {
        return RestResult.genFailResult("namespace不能为空");
    }
    if (StringUtils.isBlank(taskCode)) {
        return RestResult.genFailResult("taskCode不能为空");
    }
    try {
        //调查询日志接口的taskReqId，没有业务含义，以70开头
        String taskReqId = "70" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
        //调用查询事件接口
        IcspResultVo queryEventResultVo = icspService.logQuery(taskReqId, name, namespace, "10", userId, tenantId, taskCode);
        log.info("多云管查询接口返回值:[{}]", JSON.toJSONString(queryEventResultVo));
        if (queryEventResultVo == null) {
            //调接口查询失败
            return RestResult.genFailResult("未查询到容器日志");
        }
        String code = queryEventResultVo.getCode();
        String message = queryEventResultVo.getMessage();
        if (code.equals("0")) {
            //查询成功
            Object data = queryEventResultVo.getData();
            JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(data));
            return RestResult.genSuccessResult("查询成功", jsonObject);
        } else {
            return RestResult.genFailResult("查询容器日志失败: [{}]", message);
        }
    } catch (Exception e) {
        log.info("查询容器日志异常", e);
        return RestResult.genFailResult("查询容器日志异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.IcspResultVo
com.eshore.gdai.trainingcenter.vo.pod.Event
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private IcspService icspService;
@Value("${icsp.userId}")
private String userId;
@Value("${icsp.tenantId}")
private String tenantId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiProjectVo gdaiProject) {
    log.info("GdaiProjectServiceImpl.add params: [{}]", JSON.toJSONString(gdaiProject));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    String projectName = gdaiProject.getProjectName();
    Long groupId = gdaiProject.getGroupId();
    Long projectCoreNumber = gdaiProject.getProjectCoreNumber();
    Long projectCpuSize = gdaiProject.getProjectCpuSize();
    Long projectGpuSize = gdaiProject.getProjectGpuSize();
    Long projectDiskSize = gdaiProject.getProjectDiskSize();
    if (StringUtils.isBlank(projectName)) {
        return RestResult.genFailResult("项目名称不能为空");
    }
    if (groupId == null) {
        return RestResult.genFailResult("团队ID不能为空");
    }
    if (projectCoreNumber == null) {
        return RestResult.genFailResult("申请核数不能为空");
    }
    if (projectCpuSize == null) {
        return RestResult.genFailResult("申请CPU大小不能为空");
    }
    if (projectGpuSize == null) {
        return RestResult.genFailResult("申请GPU大小不能为空");
    }
    if (projectDiskSize == null) {
        return RestResult.genFailResult("申请磁盘大小不能为空");
    }
    try {
        Date curDate = new Date();
        gdaiProject.setCreatorId(userId);
        gdaiProject.setCreateTime(curDate);
        gdaiProject.setModifyTime(curDate);
        //1-审核中 2-通过 3-拒绝
        gdaiProject.setExamineStatus("1");
        gdaiProjectService.insert(gdaiProject);
        Long projectId = gdaiProject.getProjectId();
        //dify
        if (gdaiProject.getGdaiDifyProject() != null) {
            GdaiDifyProject gdaiDifyProject = gdaiProject.getGdaiDifyProject();
            gdaiDifyProject.setProjectId(projectId);
            gdaiDifyProject.setProjectName(projectName);
            gdaiDifyProject.setCreatorId(userId);
            gdaiDifyProject.setCreateTime(curDate);
            gdaiDifyProject.setModifyTime(curDate);
            gdaiDifyProjectService.insert(gdaiDifyProject);
        }
        //            //创建namespace
        //            k8sClientOperator.createNamespaceIfNotExist(GdaiConstant.NAMESPACE_PREFIX + projectId);
        //拼接申请的资源信息
        String resStr = "项目所需CORE:" + projectCoreNumber + ",CPU:" + projectCpuSize + ",GPU:" + projectGpuSize + ",DISK:" + projectDiskSize;
        GdaiWorkflowApprovalApplyVo gdaiWorkflowApprovalApplyVo = new GdaiWorkflowApprovalApplyVo();
        gdaiWorkflowApprovalApplyVo.setTaskId(projectId);
        gdaiWorkflowApprovalApplyVo.setApplyTitle("AI项目资源申请(" + projectName + ")");
        gdaiWorkflowApprovalApplyVo.setApplyContent(resStr);
        gdaiWorkflowApprovalApplyVo.setApplyType("1");
        gdaiWorkflowApprovalApplyVo.setCreatorId(userId);
        FeignServiceHelper.addApplyInfo(userClient, gdaiWorkflowApprovalApplyVo);
    } catch (Exception e) {
        log.info("新增项目异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.GdaiWorkflowApprovalApplyVo
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiDifyProject
com.eshore.gdai.trainingcenter.entity.GdaiProject
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private GdaiDifyProjectService gdaiDifyProjectService;
@Resource
private HttpServletRequest request;
@Resource
private UserClient userClient;
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为update的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult update(GdaiProjectVo gdaiProject) throws Exception {
    log.info("GdaiProjectServiceImpl.update params: [{}]", JSON.toJSONString(gdaiProject));
    Long projectId = gdaiProject.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    String namespace = GdaiConstant.NAMESPACE_PREFIX + projectId;
    //修复水平越权问题
    GdaiProject project = checkGdaiProject(user, projectId);
    try {
        if (Objects.equals(project.getExamineStatus(), "1")) {
            //examineStatus 1-审核中 2-通过 3-拒绝  是通过的创建namespace、quota
            if (Objects.equals(gdaiProject.getExamineStatus(), "2")) {
                try {
                    //查询namespace是否已经存在
                    NamespaceBo namespaceBo = namespaceService.get("", namespace);
                    if (namespaceBo != null) {
                        return RestResult.genSuccessResult("该项目名已经被使用了！");
                    }
                    ResourceQuotaBo resourceQuotaBo = resourceQuotaService.get("", namespace, namespace);
                    if (resourceQuotaBo != null) {
                        return RestResult.genSuccessResult("该项目名已经被使用了！");
                    }
                    //创建namespace 命名空间
                    namespaceBo = namespaceService.createNamespace("", namespace);
                    //创建quota 配额
                    resourceQuotaBo = resourceQuotaService.create("", namespace, namespace, project.getProjectCoreNumber(), project.getProjectCpuSize(), null, project.getProjectGpuSize(), null);
                    //创建secret 镜像拉取凭证
                    secretService.createDockerconfigSecret("", namespace, "gdai-harbor", IP + ":" + PORT, HARBOR_USERNAME, HARBOR_PASSWORD, "gdai@chinatelecom.cn");
                } catch (Exception e) {
                    log.info("修改项目信息异常", e);
                    //异常如果namespace创建了，那么要删除
                    NamespaceBo namespaceBo = namespaceService.get("", namespace);
                    if (namespaceBo != null) {
                        namespaceService.delete("", namespace);
                    }
                    return RestResult.genFailResult("修改异常");
                }
            }
        } else if (Objects.equals(project.getExamineStatus(), "2")) {
            //更新配额
            resourceQuotaService.patch("", namespace, namespace, gdaiProject.getProjectCoreNumber(), gdaiProject.getProjectCpuSize(), null, gdaiProject.getProjectGpuSize(), null);
        }
        BeanUtils.copyProperties(gdaiProject, project);
        Date curDate = new Date();
        project.setModifyTime(curDate);
        project.setModifierId(user.getId());
        gdaiProjectService.updateById(project);
        if (gdaiProject.getGdaiDifyProject() != null) {
            GdaiDifyProject difyProject = gdaiDifyProjectService.getDifyProjectByProjectId(projectId);
            if (difyProject != null) {
                difyProject.setMembers(gdaiProject.getGdaiDifyProject().getMembers());
                difyProject.setApps(gdaiProject.getGdaiDifyProject().getApps());
                difyProject.setVectorSpace(gdaiProject.getGdaiDifyProject().getVectorSpace());
                difyProject.setAnnotationQuotaLimit(gdaiProject.getGdaiDifyProject().getAnnotationQuotaLimit());
                difyProject.setDocumentsUploadQuota(gdaiProject.getGdaiDifyProject().getDocumentsUploadQuota());
                difyProject.setModifyTime(curDate);
                gdaiDifyProjectService.updateById(difyProject);
            } else {
                GdaiDifyProject gdaiDifyProject = gdaiProject.getGdaiDifyProject();
                gdaiDifyProject.setProjectId(projectId);
                gdaiDifyProject.setProjectName(project.getProjectName());
                gdaiDifyProject.setCreatorId(project.getCreatorId());
                gdaiDifyProject.setCreateTime(curDate);
                gdaiDifyProject.setModifyTime(curDate);
                gdaiDifyProjectService.insert(gdaiDifyProject);
            }
        }
    } catch (Exception e) {
        log.info("修改项目信息异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiDifyProject
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.k8s.domain.bo.NamespaceBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.ResourceQuotaBo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Date
java.util.Objects
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private GdaiDifyProjectService gdaiDifyProjectService;
@Resource
private NamespaceService namespaceService;
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private SecretService secretService;
@Resource
private HttpServletRequest request;
/**
 * Harbor登录用户名
 */
@Value("${harbor.username}")
private String HARBOR_USERNAME;
/**
 * 登录密码
 */
@Value("${harbor.password}")
private String HARBOR_PASSWORD;
/**
 * Harbor的登录地址
 */
@Value("${harbor.ip}")
private String IP;
/**
 * Harbor的登录地址
 */
@Value("${harbor.port}")
private String PORT;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为updateStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateStatus(GdaiProject gdaiProject) {
    log.info("GdaiProjectServiceImpl.updateStatus params: [{}]", JSON.toJSONString(gdaiProject));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long projectId = gdaiProject.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    String examineStatus = gdaiProject.getExamineStatus();
    if (StringUtils.isBlank(examineStatus)) {
        return RestResult.genFailResult("状态不能为空");
    }
    try {
        //修复水平越权问题
        GdaiProject project = checkGdaiProject(user, projectId);
        BeanUtils.copyProperties(gdaiProject, project);
        Date curDate = new Date();
        project.setModifyTime(curDate);
        project.setModifierId(user.getId());
        gdaiProjectService.updateById(project);
    } catch (Exception e) {
        log.info("修改项目状态异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiProject
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiProject gdaiProject) throws TrainginCenterException {
    log.info("GdaiProjectServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiProject));
    Long projectId = gdaiProject.getProjectId();
    if (projectId == null) {
        RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    String namespace = GdaiConstant.NAMESPACE_PREFIX + projectId;
    //修复水平越权问题
    GdaiProject project = checkGdaiProject(user, projectId);
    try {
        //删除之前检查该项目是否有模型在占用，如果占用则提示不能删除 TBD
        //            GdaiProject project = gdaiProjectService.selectById(projectId);
        //            if (project == null) {
        //                return RestResult.genFailResult("该项目不存在");
        //            }
        ResourceQuotaBo resourceQuotaBo = resourceQuotaService.get("", namespace, namespace);
        if (resourceQuotaBo != null) {
            RestResult resourceQuotaResult = resourceQuotaService.delete("", namespace, namespace);
            if (resourceQuotaResult != null && resourceQuotaResult.getSuccess() != 0) {
                throw new TrainginCenterException("删除配额失败");
            }
        }
        NamespaceBo namespaceBo = namespaceService.get("", namespace);
        if (namespaceBo != null) {
            RestResult namespaceResult = namespaceService.delete("", namespace);
            if (namespaceResult != null && namespaceResult.getSuccess() != 0) {
                throw new TrainginCenterException("删除命名空间失败");
            }
        }
        gdaiProjectService.deleteById(projectId);
    } catch (Exception e) {
        log.info("删除项目信息异常", e);
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.k8s.domain.bo.NamespaceBo
com.eshore.gdai.trainingcenter.k8s.domain.bo.ResourceQuotaBo
org.springframework.stereotype.Service
javax.annotation.Resource
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private NamespaceService namespaceService;
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为queryProject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryProject(GdaiProjectVo gdaiProjectVo) {
    log.info("GdaiProjectServiceImpl.queryProject params: [{}]", JSON.toJSONString(gdaiProjectVo));
    List<String> desc = new ArrayList<>();
    desc.add("create_time");
    List<GdaiProjectVo> list = new ArrayList<>();
    Page<GdaiProject> gdaiProjectPage = gdaiProjectService.selectPage(new Page<>(gdaiProjectVo.getPageNumber(), gdaiProjectVo.getPageCount()), new EntityWrapper<GdaiProject>().orderDesc(desc));
    if (gdaiProjectPage != null && gdaiProjectPage.getRecords().size() > 0) {
        List<GdaiProject> records = gdaiProjectPage.getRecords();
        for (GdaiProject gdaiProject : records) {
            gdaiProjectVo = new GdaiProjectVo();
            BeanUtils.copyProperties(gdaiProject, gdaiProjectVo);
            list.add(gdaiProjectVo);
        }
    }
    UiPage<GdaiProjectVo> uiPage = new UiPage<>();
    uiPage.setTotal(gdaiProjectPage.getTotal());
    uiPage.setPageSize(gdaiProjectPage.getSize());
    uiPage.setPages(gdaiProjectPage.getPages());
    uiPage.setPageNum(gdaiProjectPage.getCurrent());
    uiPage.setList(list);
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.vo.GdaiProjectVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为queryProjectNoPage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryProjectNoPage(GdaiProject gdaiProject) {
    log.info("GdaiProjectServiceImpl.queryProjectNoPage params: [{}]", JSON.toJSONString(gdaiProject));
    List<String> desc = new ArrayList<>();
    desc.add("modify_time");
    List<GdaiProject> gdaiProjects;
    Long projectId = gdaiProject.getProjectId();
    try {
        gdaiProjects = gdaiProjectService.selectList(new EntityWrapper<GdaiProject>().eq(projectId != null, "project_id", projectId).orderDesc(desc));
    } catch (Exception e) {
        log.info("查询项目信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(gdaiProjects);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiProject
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为queryProjectById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryProjectById(GdaiProject gdaiProject) throws TrainginCenterException {
    log.info("GdaiProjectServiceImpl.queryProjectById params: [{}]", JSON.toJSONString(gdaiProject));
    Long projectId = gdaiProject.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiProject project = checkRoleGdaiProject(user, projectId);
    try {
        //TBD
        if (project != null && Objects.equals(project.getExamineStatus(), "2")) {
            updateProjectResource(projectId);
        }
        project = gdaiProjectService.selectById(projectId);
        GdaiProjectVo gdaiProjectVo = new GdaiProjectVo();
        BeanUtils.copyProperties(project, gdaiProjectVo);
        GdaiDifyProject gdaiDifyProject = gdaiDifyProjectService.getDifyProjectByProjectId(projectId);
        if (gdaiDifyProject != null) {
            gdaiProjectVo.setGdaiDifyProject(gdaiDifyProject);
        }
        return RestResult.genSuccessResult(gdaiProjectVo);
    } catch (Exception e) {
        log.info("查询项目信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiDifyProject
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.vo.GdaiProjectVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Objects
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private GdaiDifyProjectService gdaiDifyProjectService;
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为queryProjectByUserId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryProjectByUserId(GdaiProjectVo gdaiProjectVo) {
    log.info("GdaiProjectServiceImpl.queryProjectByUserId params: [{}]", JSON.toJSONString(gdaiProjectVo));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    Long userId = user.getId();
    //根据用户ID查询自己是否有关联模型开发团队，如果有则获取团队ID当做查询条件，查询团队关联的项目列表
    UserGroupUsersVo userGroupUsersVo = new UserGroupUsersVo();
    userGroupUsersVo.setUserId(userId);
    userGroupUsersVo.setGroupType("MDDEV");
    Set<Long> groupIdList = FeignServiceHelper.getUserGroupByUserId(userClient, userGroupUsersVo);
    UiPage<GdaiProjectVo> uiPage = new UiPage<>();
    List<GdaiProjectVo> list = new ArrayList<>();
    List<String> desc = new ArrayList<>();
    desc.add("project_id");
    Page<GdaiProject> gdaiProjectPage = null;
    if (groupIdList != null && groupIdList.size() > 0) {
        gdaiProjectPage = gdaiProjectService.selectPage(new Page<>(gdaiProjectVo.getPageNumber(), gdaiProjectVo.getPageCount()), new EntityWrapper<GdaiProject>().in(groupIdList.size() > 0, "group_id", groupIdList).eq("examine_status", "2").orderDesc(desc));
    }
    if (gdaiProjectPage != null && gdaiProjectPage.getRecords().size() > 0) {
        List<GdaiProject> records = gdaiProjectPage.getRecords();
        for (GdaiProject gdaiProject : records) {
            gdaiProjectVo = new GdaiProjectVo();
            BeanUtils.copyProperties(gdaiProject, gdaiProjectVo);
            list.add(gdaiProjectVo);
        }
        uiPage.setTotal(gdaiProjectPage.getTotal());
        uiPage.setPageSize(gdaiProjectPage.getSize());
        uiPage.setPages(gdaiProjectPage.getPages());
        uiPage.setPageNum(gdaiProjectPage.getCurrent());
        uiPage.setList(list);
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.entity.usercenter.UserGroupUsersVo
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.vo.GdaiProjectVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
java.util.Set
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为queryProjectByUserId的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Set<Long> queryProjectByUserId(Long userId) {
    log.info("GdaiProjectServiceImpl.queryProjectByUserId params: [{}]", userId);
    //根据用户ID查询自己是否有关联模型开发团队，如果有则获取团队ID当做查询条件，查询团队关联的项目列表
    UserGroupUsersVo userGroupUsersVo = new UserGroupUsersVo();
    userGroupUsersVo.setUserId(userId);
    userGroupUsersVo.setGroupType("MDDEV");
    Set<Long> groupIdList = FeignServiceHelper.getUserGroupByUserId(userClient, userGroupUsersVo);
    Set<Long> projectIds = new HashSet<>();
    List<String> desc = new ArrayList<>();
    desc.add("project_id");
    List<GdaiProject> gdaiProject = null;
    if (groupIdList != null && !groupIdList.isEmpty()) {
        gdaiProject = gdaiProjectService.selectList(new EntityWrapper<GdaiProject>().in(!groupIdList.isEmpty(), "group_id", groupIdList).eq("examine_status", "2").orderDesc(desc));
    }
    if (gdaiProject != null && gdaiProject.size() > 0) {
        projectIds = gdaiProject.stream().map(GdaiProject::getProjectId).collect(Collectors.toCollection(HashSet::new));
    }
    return projectIds;
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.entity.usercenter.UserGroupUsersVo
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.eshore.gdai.trainingcenter.entity.GdaiProject
org.springframework.stereotype.Service
java.util.ArrayList
java.util.HashSet
java.util.List
java.util.Set
java.util.stream.Collectors
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为queryApplications的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryApplications(Long projectId) throws TrainginCenterException {
    log.info("GdaiProjectServiceImpl.queryApplications params: [{}]", projectId);
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiProject project = checkRoleGdaiProject(user, projectId);
    try {
        List<ApplicationVo> result = new ArrayList<>();
        List<ApplicationVo> dev = gdaiDevModelService.queryDevModelList(projectId);
        if (dev != null && dev.size() > 0) {
            result.addAll(dev);
        }
        List<ApplicationVo> train = gdaiTrainingModelService.queryTrainingModelList(projectId);
        if (train != null && train.size() > 0) {
            result.addAll(train);
        }
        List<ApplicationVo> deploy = gdaiModelDeployService.queryDeployModelList(projectId);
        if (deploy != null && deploy.size() > 0) {
            result.addAll(deploy);
        }
        return RestResult.genSuccessResult(result);
    } catch (Exception e) {
        log.error("GdaiProjectServiceImpl.queryApplications Exception", e.getMessage());
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.vo.ApplicationVo
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private HttpServletRequest request;
@Resource
private GdaiDevModelService gdaiDevModelService;
@Resource
private GdaiTrainingModelService gdaiTrainingModelService;
@Resource
private GdaiModelDeployService gdaiModelDeployService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为syncProjectResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult syncProjectResource(Long projectId) throws TrainginCenterException {
    log.info("GdaiProjectServiceImpl.syncProjectResource params: [{}]", projectId);
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //修复水平越权问题
    GdaiProject project = checkGdaiProject(user, projectId);
    try {
        updateProjectResource(project.getProjectId(), user.getId());
    } catch (Exception e) {
        log.info("同步项目资源信息异常", e);
        return RestResult.genFailResult("修改异常");
    }
    return RestResult.genSuccessResult("同步项目资源信息成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiProject
org.springframework.stereotype.Service
javax.annotation.Resource
### 类级别的变量
@Resource
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为updateProjectResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void updateProjectResource(Long projectId) {
    try {
        updateProjectResource(projectId, null);
    } catch (Exception e) {
        log.error("同步项目资源信息异常", e);
    }
}
### 类导入的包
javax.annotation.Resource
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为updateProjectResource的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public synchronized void updateProjectResource(Long projectId, Long userId) throws Exception {
    log.info("GdaiProjectServiceImpl.updateProjectResource params: [{},{}]", projectId, userId);
    try {
        GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
        if (gdaiProject == null) {
            throw new TrainginCenterException("该项目不存在");
        }
        NamespaceResourceInfoVo resourceInfo = namespaceService.countNamespaceResourceInfo("", GdaiConstant.NAMESPACE_PREFIX + projectId);
        if (resourceInfo != null) {
            gdaiProject.setProjectCoreNumber(resourceInfo.getHardCpu());
            gdaiProject.setProjectCpuSize(resourceInfo.getHardMemory() * 1024);
            gdaiProject.setProjectGpuSize(resourceInfo.getHardGpuMemory());
            gdaiProject.setUsedCoreNumber(resourceInfo.getUsedCpu());
            gdaiProject.setUsedCpuSize(resourceInfo.getUsedMemory() * 1024);
            gdaiProject.setUsedGpuSize(resourceInfo.getUsedGpuMemory());
            //算法开发
            if (resourceInfo.getBizUsed() != null && resourceInfo.getBizUsed().get("dev_model") != null) {
                gdaiProject.setDevUsedCoreNumber(resourceInfo.getBizUsed().get("dev_model").getCpu());
                gdaiProject.setDevUsedCpuSize(resourceInfo.getBizUsed().get("dev_model").getMemory() * 1024);
                gdaiProject.setDevUsedGpuSize(resourceInfo.getBizUsed().get("dev_model").getGpuMemory());
            } else {
                gdaiProject.setDevUsedCoreNumber(0L);
                gdaiProject.setDevUsedCpuSize(0L);
                gdaiProject.setDevUsedGpuSize(0L);
            }
            //模型训练
            if (resourceInfo.getBizUsed() != null && resourceInfo.getBizUsed().get("train_model") != null) {
                gdaiProject.setTrainUsedCoreNumber(resourceInfo.getBizUsed().get("train_model").getCpu());
                gdaiProject.setTrainUsedCpuSize(resourceInfo.getBizUsed().get("train_model").getMemory() * 1024);
                gdaiProject.setTrainUsedGpuSize(resourceInfo.getBizUsed().get("train_model").getGpuMemory());
            } else {
                gdaiProject.setTrainUsedCoreNumber(0L);
                gdaiProject.setTrainUsedCpuSize(0L);
                gdaiProject.setTrainUsedGpuSize(0L);
            }
            //模型部署
            if (resourceInfo.getBizUsed() != null && resourceInfo.getBizUsed().get("deploy_model") != null) {
                gdaiProject.setDeployUsedCoreNumber(resourceInfo.getBizUsed().get("deploy_model").getCpu());
                gdaiProject.setDeployUsedCpuSize(resourceInfo.getBizUsed().get("deploy_model").getMemory() * 1024);
                gdaiProject.setDeployUsedGpuSize(resourceInfo.getBizUsed().get("deploy_model").getGpuMemory());
            } else {
                gdaiProject.setDeployUsedCoreNumber(0L);
                gdaiProject.setDeployUsedCpuSize(0L);
                gdaiProject.setDeployUsedGpuSize(0L);
            }
        }
        Date curDate = new Date();
        gdaiProject.setModifyTime(curDate);
        if (userId != null) {
            gdaiProject.setModifierId(userId);
        }
        gdaiProjectService.updateById(gdaiProject);
    } catch (Exception e) {
        throw new TrainginCenterException("更新项目资源失败！" + e.getMessage());
    }
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.k8s.domain.vo.NamespaceResourceInfoVo
org.springframework.stereotype.Service
javax.annotation.Resource
java.util.Date
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private NamespaceService namespaceService;
@Resource
private GdaiProjectMapper gdaiProjectMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为checkGdaiProject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiProject checkGdaiProject(User user, Long projectId) throws TrainginCenterException {
    GdaiProject project = gdaiProjectMapper.selectById(projectId);
    if (project == null) {
        throw new TrainginCenterException("记录不存在");
    } else {
        //判断登录用户角色
        //运营管理员角色
        boolean operAdminRole = SessionUtils.isOperAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(operAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(project.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return project;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiProject
### 类级别的变量
@Resource
private GdaiProjectMapper gdaiProjectMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectServiceImpl中有一个名为checkRoleGdaiProject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiProject checkRoleGdaiProject(User user, Long projectId) throws TrainginCenterException {
    GdaiProject project = gdaiProjectMapper.selectById(projectId);
    if (project == null) {
        throw new TrainginCenterException("记录不存在");
    } else {
        //判断登录用户角色
        //            //AI数据标注员角色 ailabeloper
        //            boolean aiLabelOperRole = SessionUtils.isAiLabeloperRole(user);
        //AI模型开发员角色 aimodeldev
        boolean aiModelDevRole = SessionUtils.isAiModelDevRole(user);
        //AI团队管理员角色 aigroupadmin
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //运营管理员角色
        boolean operAdminRole = SessionUtils.isOperAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(operAdminRole || superAdminRole || aiModelDevRole || aiGroupAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(project.getCreatorId())) {
                throw new TrainginCenterException("无权限执行该操作");
            }
        }
        return project;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiProject
### 类级别的变量
@Resource
private GdaiProjectMapper gdaiProjectMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiProjectUserServiceImpl中有一个名为queryProjectUser的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryProjectUser(GdaiProjectVo gdaiProject) {
    log.info("GdaiProjectServiceImpl.queryProjectNoPage params: [{}]", JSON.toJSONString(gdaiProject));
    Long projectId = gdaiProject.getProjectId();
    try {
        GdaiProject project = gdaiProjectService.selectById(projectId);
        if (project == null) {
            return RestResult.genFailResult("项目不存在");
        }
        JSONObject projectUser = new JSONObject();
        projectUser.put("projectName", project.getProjectName());
        List<JSONObject> users = new ArrayList<>();
        List<User> groupUsers = FeignServiceHelper.getGroupUsers(userClient, project.getGroupId());
        for (User groupUser : groupUsers) {
            if (StringUtils.isNotEmpty(groupUser.getEmail())) {
                JSONObject user = new JSONObject();
                user.put("email", groupUser.getEmail());
                user.put("username", groupUser.getUsername());
                //AI团队管理员角色 aigroupadmin
                boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(groupUser);
                //运营管理员角色
                boolean operAdminRole = SessionUtils.isOperAdminRole(groupUser);
                //超级管理员角色
                boolean superAdminRole = SessionUtils.isSuperAdminRole(groupUser);
                if (aiGroupAdminRole || operAdminRole || superAdminRole) {
                    user.put("role", "admin");
                } else {
                    user.put("role", "editor");
                }
                users.add(user);
            }
        }
        projectUser.put("users", users);
        return RestResult.genSuccessResult(projectUser);
    } catch (Exception e) {
        log.info("查询项目信息异常", e);
        return RestResult.genFailResult("查询异常");
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.service.GdaiProjectService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiProjectService gdaiProjectService;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiStatisticsServiceImpl中有一个名为addBatch的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult addBatch(List<GdaiStatisticsVo> gdaiStatisticsVo) {
    List<GdaiStatistics> gdaiStatistics = new ArrayList<>();
    for (GdaiStatisticsVo statisticsVo : gdaiStatisticsVo) {
        GdaiStatistics gdaiStatistic = new GdaiStatistics();
        gdaiStatistic.setProjectId(statisticsVo.getProjectId());
        JSONObject metrics = new JSONObject();
        metrics.put("metrics_type", statisticsVo.getMetricsType());
        metrics.put("metrics_value", statisticsVo.getMetricsValue());
        gdaiStatistic.setMetrics(metrics);
        gdaiStatistic.setCreateTime(new Date());
        gdaiStatistics.add(gdaiStatistic);
    }
    Integer result = gdaiStatisticsMapper.addBatch(gdaiStatistics);
    if (result > 0) {
        return RestResult.genSuccessResult("添加指标成功");
    }
    return RestResult.genFailResult("添加指标失败");
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiStatistics
com.eshore.gdai.trainingcenter.enums.MetricsType
com.eshore.gdai.trainingcenter.vo.GdaiStatisticsVo
io.swagger.models.auth.In
java.util.ArrayList
java.util.Date
java.util.List
java.util.Map
### 类级别的变量
@Resource
private GdaiStatisticsMapper gdaiStatisticsMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiStatisticsServiceImpl中有一个名为getStatistics的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getStatistics(Long project) throws Exception {
    //通过redis取到枚举MetricsType数据
    JSONObject result = new JSONObject();
    if (project != null) {
        //遍历枚举MetricsType
        for (MetricsType metrics : MetricsType.values()) {
            Object count = redisUtils.hget(metrics.getCode(), String.valueOf(project));
            if (count != null) {
                result.put(metrics.getCode(), count);
            } else {
                result.put(metrics.getCode(), 0);
            }
        }
    } else {
        //遍历枚举MetricsType
        for (MetricsType metrics : MetricsType.values()) {
            Map<String, Object> metricMap = redisUtils.hmget(metrics.getCode());
            Object sum = metricMap.entrySet().parallelStream().mapToInt(map -> (Integer.parseInt((String) map.getValue()))).sum();
            result.put(metrics.getCode(), sum);
        }
    }
    return RestResult.genSuccessResult(result);
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.enums.MetricsType
io.swagger.models.auth.In
java.util.Map
### 类级别的变量
@Resource
private RedisUtils redisUtils;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiStatisticsServiceImpl中有一个名为getFrameworkUser的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getFrameworkUser() throws Exception {
    JSONObject result = new JSONObject();
    Object count = redisUtils.sGetSetSize("frameworkUser");
    result.put("frameworkUser", count);
    return RestResult.genSuccessResult(result);
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.result.RestResult
### 类级别的变量
@Resource
private RedisUtils redisUtils;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiStatisticsServiceImpl中有一个名为clearCache的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult clearCache() throws Exception {
    for (MetricsType metrics : MetricsType.values()) {
        redisUtils.delete(metrics.getCode());
    }
    redisUtils.delete("frameworkUser");
    return RestResult.genSuccessResult("清除成功");
}
### 类导入的包
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.enums.MetricsType
### 类级别的变量
@Resource
private RedisUtils redisUtils;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingEnvServiceImpl中有一个名为queryTrainingEnv的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTrainingEnv(GdaiTrainingEnvVo gdaiTrainingEnvVo) {
    log.info("GdaiTrainingEnvServiceImpl.queryTrainingEnv params: [{}]", JSON.toJSONString(gdaiTrainingEnvVo));
    String bizType = gdaiTrainingEnvVo.getBizType();
    String deployPool = gdaiTrainingEnvVo.getDeployPool();
    if (StringUtils.isBlank(bizType)) {
        return RestResult.genFailResult("业务类型不能为空");
    }
    if (StringUtils.isBlank(deployPool)) {
        return RestResult.genFailResult("资源池类型不能为空");
    }
    List<GdaiTrainingEnv> gdaiTrainingEnvs = gdaiTrainingEnvMapper.selectByBizType(bizType, deployPool);
    return RestResult.genSuccessResult(gdaiTrainingEnvs);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiTrainingEnv
com.eshore.gdai.trainingcenter.service.GdaiTrainingEnvService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.List
### 类级别的变量
@Resource
private GdaiTrainingEnvMapper gdaiTrainingEnvMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为add的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult add(GdaiTrainingModelVo gdaiTrainingModelVo) {
    log.info("GdaiTrainingModelServiceImpl.add params: {}", JSON.toJSONString(gdaiTrainingModelVo));
    GdaiTrainingModel gdaiTrainingModel = new GdaiTrainingModel();
    BeanUtils.copyProperties(gdaiTrainingModelVo, gdaiTrainingModel);
    Long imageId = gdaiTrainingModelVo.getImageId();
    Long projectId = gdaiTrainingModelVo.getProjectId();
    Long algorithmId = gdaiTrainingModelVo.getAlgorithmId();
    String trainName = gdaiTrainingModelVo.getTrainName();
    String shareFlag = gdaiTrainingModelVo.getShareFlag();
    Long version = gdaiTrainingModel.getTrainVersion();
    String datasetSource = gdaiTrainingModel.getDatasetSource();
    Long creatorId = gdaiTrainingModel.getCreatorId();
    String processUnitType = gdaiTrainingModel.getProcessUnitType();
    //        String algorithmPath = gdaiTrainingModel.getAlgorithmPath();
    //        String modelSavePath = gdaiTrainingModel.getModelSavePath();
    //        String core = gdaiTrainingModel.getCore();
    //        String memorySize = gdaiTrainingModel.getMemorySize();
    //        String gpuSize = gdaiTrainingModel.getGpuSize();
    //        String isCustRes = gdaiTrainingModel.getIsCustRes();
    //        String commandAndArgs = gdaiTrainingModel.getCommandAndArgs();
    if (imageId == null) {
        return RestResult.genFailResult("机器学习框架镜像ID");
    }
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    if (StringUtils.isBlank(trainName)) {
        return RestResult.genFailResult("任务名称不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    if (version == null) {
        return RestResult.genFailResult("版本号不能为空");
    }
    if (StringUtils.isBlank(datasetSource)) {
        return RestResult.genFailResult("数据集来源不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    //        if (StringUtils.isBlank(algorithmPath)) {
    //            return RestResult.genFailResult("算法保存路径不能为空");
    //        }
    //        if (StringUtils.isBlank(modelSavePath)) {
    //            return RestResult.genFailResult("模型结果保存路径不能为空");
    //        }
    //        if (StringUtils.isBlank(core)) {
    //            return RestResult.genFailResult("核心数不能为空");
    //        }
    //        if (StringUtils.isBlank(memorySize)) {
    //            return RestResult.genFailResult("内存大小不能为空");
    //        }
    //        if (StringUtils.isBlank(gpuSize)) {
    //            return RestResult.genFailResult("GPU大小不能为空");
    //        }
    //        if (StringUtils.isBlank(commandAndArgs)) {
    //            return RestResult.genFailResult("执行参数不能为空");
    //        }
    //        if (!CommonTools.checkCommandAndArgs(commandAndArgs)) {
    //            return RestResult.genFailResult("执行参数不合法");
    //        }
    try {
        Date date = new Date();
        //根据项目ID查询该项目当前资源占用情况
        GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
        if (gdaiProject == null) {
            return RestResult.genFailResult("该项目不存在");
        }
        String context = gdaiTrainingModel.getContext();
        JSONObject contextObj = new JSONObject();
        if (StringUtils.isNotEmpty(context)) {
            contextObj = JSON.parseObject(context);
        }
        String core = "";
        String memorySize = "";
        String gpuSize = "0";
        if (contextObj != null && !contextObj.isEmpty()) {
            core = contextObj.getString("core");
            memorySize = contextObj.getString("memory");
            if (contextObj.getJSONObject("gpu") != null) {
                gpuSize = contextObj.getJSONObject("gpu").getString("gpuSize");
            }
        }
        if (StringUtils.isBlank(core)) {
            return RestResult.genFailResult("核心数不能为空");
        }
        if (StringUtils.isBlank(memorySize)) {
            return RestResult.genFailResult("内存大小不能为空");
        }
        RestResult limitsOfResources = resourceQuotaService.reachLimitsOfResources("", GdaiConstant.NAMESPACE_PREFIX + projectId, Integer.parseInt(core), Integer.parseInt(memorySize), //TBD vcuda-core 待添加字段
        Integer.parseInt("0"), Integer.parseInt(gpuSize), // 暂时用不到
        Integer.parseInt("0"));
        if (limitsOfResources != null && limitsOfResources.getSuccess() != 0) {
            return RestResult.genFailResult(limitsOfResources.getMessage());
        }
        //            //算力大小默认设置为50%
        //            gdaiTrainingModel.setComputingPower("50");
        //根据imageId查询yaml模板
        GdaiImage gdaiImage = gdaiImageMapper.selectById(imageId);
        if (gdaiImage != null) {
            gdaiTrainingModel.setTrainYmlContent(gdaiImage.getTrainYmlContent());
        }
        gdaiTrainingModel.setStatus("Pending");
        gdaiTrainingModel.setProcessUnitType(processUnitType);
        //            gdaiTrainingModel.setCore(core);
        //            gdaiTrainingModel.setMemorySize(memorySize);
        //这里默认使用1张卡
        //            gdaiTrainingModel.setCardNumber(number);
        //            gdaiTrainingModel.setGpuSize(gpuSize);
        //            long size = Long.parseLong(gpuSize) * 1024 * 1024;
        //            String gpuSizeChange = UnitConvertUtils.getSize(size);
        //            String env = core + "核CPU" + memorySize + "内存_" + gpuSizeChange;
        //            gdaiTrainingModel.setTrainingEnvironment(env);
        //            gdaiTrainingModel.setIsCustRes(isCustRes);
        //            algorithmPath = algorithmPath.replaceAll("/fileManager", "").trim();
        //            gdaiTrainingModel.setAlgorithmPath(algorithmPath);
        gdaiTrainingModel.setCreatorId(creatorId);
        gdaiTrainingModel.setCreateTime(date);
        gdaiTrainingModel.setModifierId(creatorId);
        gdaiTrainingModel.setModifyTime(date);
        //解决字段非空约束,默认赋值为空
        gdaiTrainingModel.setCntrMsg("");
        gdaiTrainingModel.setCommandAndArgs("");
        gdaiTrainingModel.setCore("0");
        gdaiTrainingModel.setMemorySize("");
        gdaiTrainingModel.setGpuSize("");
        gdaiTrainingModel.setIsCustRes("");
        gdaiTrainingModel.setAlgorithmPath("");
        gdaiTrainingModel.setModelSavePath("");
        gdaiTrainingModelMapper.insert(gdaiTrainingModel);
        //            Long trainId = gdaiTrainingModel.getTrainId();
        //            gdaiTrainingModel.setTrainId(trainId);
        //拼装模型保存路径（由于模型保存路径和算法保存路径挂载在同一路径下，故将模型保存路径放在算法保存路径上一级，避免下载算法时一并将模型下载）
        //            String modelPath = algorithmPath + "/" + trainId + "/model_out/";
        //            FileUtil.createDir(modelPath);
        //            gdaiTrainingModel.setModelSavePath(modelPath);
        //            //将训练过程的参数保存在训练结果同一目录下
        //            String resultUrl = algorithmPath + "/" + trainId + "/result/";
        //            FileUtil.createDir(resultUrl);
        //            gdaiTrainingModel.setResultUrl(resultUrl);
        //            gdaiTrainingModelMapper.updateById(new GdaiTrainingModel(trainId, resultUrl, modelPath, new Date()));
        //另起线程创建job训练任务
        //            GdaiTrainingModelServiceImpl gdaiTrainingModelServiceImpl = new GdaiTrainingModelServiceImpl();
        //设置命名空间，按项目划分 gdai-projectId
        gdaiTrainingModel.setNameSpace(GdaiConstant.NAMESPACE_PREFIX + projectId);
        //            uploadThreadPool.execute(new GdaiTrainingModelServiceImpl.StartTrainJob(transactionManager, transactionStatuses, gdaiTrainingModelMapper, gdaiClusterInfoMapper, gdaiNodeInfoMapper, gdaiProjectMapper, gdaiNodeInfoService, gdaiProjectService, k8sInit2, k8sClientOperator, gdaiTrainingModelServiceImpl, gdaiTrainingModel));
        gdaiTrainModelAsyncTask.startTrainingModel(gdaiTrainingModel);
    } catch (Exception e) {
        log.info("新增训练模型记录异常", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return RestResult.genFailResult("新增异常");
    }
    return RestResult.genSuccessResult("新增成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.config.GdaiConstant
com.eshore.gdai.trainingcenter.entity.GdaiImage
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
org.springframework.transaction.TransactionStatus
org.springframework.transaction.interceptor.TransactionAspectSupport
javax.annotation.Resource
java.io.File
java.util.Date
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiImageMapper gdaiImageMapper;
@Resource
private GdaiTrainingModelService gdaiTrainingModelService;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiClusterInfoMapper gdaiClusterInfoMapper;
@Resource
private GdaiNodeInfoMapper gdaiNodeInfoMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private ResourceQuotaService resourceQuotaService;
@Resource
private GdaiTrainingModelAsyncTask gdaiTrainModelAsyncTask;
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource(name = "uploadThreadPool")
private ExecutorService uploadThreadPool;
@Resource
private PlatformTransactionManager transactionManager;
List<TransactionStatus> transactionStatuses = Collections.synchronizedList(new ArrayList<>());
/**
 * 显卡个数
 */
@Value("${card.number}")
private String number;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为updateStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    }
public RestResult updateStatus(GdaiTrainingModel gdaiTrainingModel) throws TrainginCenterException {
    log.info("GdaiTrainingModelServiceImpl.updateStatus params: [{}]", JSON.toJSONString(gdaiTrainingModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long trainId = gdaiTrainingModel.getTrainId();
    String status = gdaiTrainingModel.getStatus();
    if (trainId == null) {
        return RestResult.genFailResult("ID不能为空");
    }
    if (StringUtils.isBlank(status)) {
        return RestResult.genFailResult("状态不能为空");
    }
    //修复水平越权问题
    checkGdaiTrainingModel(user, trainId, false);
    //        gdaiTrainingModel = gdaiTrainingModelMapper.selectById(trainId);
    //        if (gdaiTrainingModel == null) {
    //            return RestResult.genFailResult("该记录不存在");
    //        }
    gdaiTrainingModelMapper.updateById(new GdaiTrainingModel(trainId, status, new Date()));
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为updateShareFlag的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult updateShareFlag(GdaiTrainingModel gdaiTrainingModel) throws TrainginCenterException {
    log.info("GdaiTrainingModelServiceImpl.updateShareFlag params: [{}]", JSON.toJSONString(gdaiTrainingModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //        Long userId = user.getId();
    Long trainId = gdaiTrainingModel.getTrainId();
    String shareFlag = gdaiTrainingModel.getShareFlag();
    if (trainId == null) {
        return RestResult.genFailResult("训练ID不能为空");
    }
    if (StringUtils.isBlank(shareFlag)) {
        return RestResult.genFailResult("共享标识不能为空");
    }
    //修复水平越权问题
    checkGdaiTrainingModel(user, trainId, false);
    //        GdaiTrainingModel trainingModel = gdaiTrainingModelMapper.selectById(trainId);
    //        if (trainingModel == null) {
    //            return RestResult.genFailResult("该记录不存在");
    //        }
    //        //修改之前判断当前修改人是否和创建人一致（该条记录的创建者才有修改权限）
    //        Long creatorId = trainingModel.getCreatorId();
    //        if (!creatorId.equals(userId)) {
    //            return RestResult.genFailResult("非创建者不能修改该状态");
    //        }
    GdaiTrainingModel training = new GdaiTrainingModel();
    training.setTrainId(trainId);
    training.setShareFlag(shareFlag);
    training.setModifyTime(new Date());
    gdaiTrainingModelMapper.updateById(training);
    return RestResult.genSuccessResult("修改成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为delete的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult delete(GdaiTrainingModel gdaiTrainingModel) {
    log.info("GdaiTrainingModelServiceImpl.delete params: [{}]", JSON.toJSONString(gdaiTrainingModel));
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    //        Long userId = user.getId();
    Long trainId = gdaiTrainingModel.getTrainId();
    if (trainId == null) {
        return RestResult.genFailResult("训练ID不能为空");
    }
    String status = null;
    String phaseStatus = null;
    try {
        //修复水平越权问题
        GdaiTrainingModel trainingModel = checkGdaiTrainingModel(user, trainId, false);
        String jobName = trainingModel.getJobName();
        String podName = trainingModel.getPodName();
        String nameSpace = trainingModel.getNameSpace();
        status = trainingModel.getStatus();
        if (StringUtils.isNotBlank(jobName) && StringUtils.isNotBlank(nameSpace)) {
            //删除job
            ApiClient client = k8sInit2.getConnection();
            BatchV1Api appsInstance = new BatchV1Api(client);
            V1JobList v1JobList = appsInstance.listNamespacedJob(nameSpace, null, null, null, null, null, null, null, null, null, null);
            List<V1Job> items = v1JobList.getItems();
            for (V1Job v1Job : items) {
                String name = v1Job.getMetadata().getName();
                if (jobName.equals(name)) {
                    appsInstance.deleteNamespacedJob(jobName, nameSpace, null, null, 0, null, "", new V1DeleteOptions());
                    break;
                }
            }
        }
        if (StringUtils.isNotBlank(podName) && StringUtils.isNotBlank(nameSpace)) {
            //删除pod
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api api = new CoreV1Api(client);
            V1PodList v1PodList = api.listNamespacedPod(nameSpace, null, null, null, null, null, null, null, null, null, null);
            List<V1Pod> items = v1PodList.getItems();
            for (V1Pod v1Pod : items) {
                String name = v1Pod.getMetadata().getName();
                phaseStatus = v1Pod.getStatus().getPhase();
                if (podName.equals(name)) {
                    api.deleteNamespacedPod(podName, nameSpace, null, null, 0, null, "", new V1DeleteOptions());
                    break;
                }
            }
        }
        //删除临时保存的模型和指标文件
        String tempPath = trainingModel.getAlgorithmPath() + File.separator + trainId;
        if (StringUtils.isNotBlank(tempPath)) {
            File file = FileUtils.getFile(tempPath);
            if (file.exists()) {
                FileUtil.deleteFile(file);
            }
        }
        //状态为Pending和Running表示任务未结束
        log.info("status=" + phaseStatus);
        if ("Pending".equals(phaseStatus) || "Running".equals(phaseStatus)) {
            log.info("releaseProject");
            //                //释放配额
            //                gdaiProjectService.releaseProject(trainingModel.getProjectId(), "train", trainingModel.getCore(), trainingModel.getMemorySize(), trainingModel.getGpuSize());
            //                //释放资源
            //                gdaiNodeInfoService.releaseNode(nodeIp, "train", trainingModel.getCore(), trainingModel.getMemorySize(), trainingModel.getGpuSize());
        }
        //根据ID删除
        gdaiTrainingModelMapper.deleteById(trainId);
        //训练记录来源：1-常规训练,2-智能标注训练
        String trainSource = trainingModel.getTrainSource();
        if ("2".equals(trainSource)) {
            //如果是智能标注训练，则删除对应的关联关系表记录
            gdaiIntelligentAnnotationTrainingMapper.delete(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("train_id", trainId));
        }
        return RestResult.genSuccessResult("删除成功");
    } catch (Exception e) {
        log.info("删除训练模型记录异常", e);
    }
    gdaiTrainingModelMapper.updateById(new GdaiTrainingModel(trainId, status, new Date()));
    return RestResult.genFailResult("删除异常");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.util.FileUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.BatchV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1DeleteOptions
io.kubernetes.client.openapi.models.V1Job
io.kubernetes.client.openapi.models.V1JobList
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private K8sInit2 k8sInit2;
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为queryTrainingModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTrainingModel(GdaiTrainingModelVo gdaiTrainingModelVo) {
    log.info("GdaiTrainingModelServiceImpl.queryTrainingModel params: [{}]}", JSON.toJSONString(gdaiTrainingModelVo));
    Long algorithmId = gdaiTrainingModelVo.getAlgorithmId();
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    String trainName = gdaiTrainingModelVo.getTrainName();
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    Long userId = user.getId();
    //判断登录用户角色
    boolean aiGroupAdminRole = CommonTools.isSuperAdminOrAiGroupAdmin(user);
    if (aiGroupAdminRole) {
        //如果是AI团队管理员则展示所有成员创建的任务
        UiPage<GdaiTrainingModelVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("train_version");
        List<GdaiTrainingModelVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiTrainingModel> wrapper = new EntityWrapper<>();
        wrapper.eq("algorithm_id", algorithmId);
        // 如果trainName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(trainName)) {
            wrapper.like("train_name", trainName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiTrainingModel> gdaiTrainingModelPage = gdaiTrainingModelService.selectPage(new Page<>(gdaiTrainingModelVo.getPageNumber(), gdaiTrainingModelVo.getPageCount()), wrapper);
        if (gdaiTrainingModelPage != null && gdaiTrainingModelPage.getRecords().size() > 0) {
            List<GdaiTrainingModel> records = gdaiTrainingModelPage.getRecords();
            for (GdaiTrainingModel gdaiTraining : records) {
                gdaiTrainingModelVo = new GdaiTrainingModelVo();
                BeanUtils.copyProperties(gdaiTraining, gdaiTrainingModelVo);
                Long creatorId = gdaiTraining.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiTrainingModelVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiTrainingModelVo);
            }
            uiPage.setTotal(gdaiTrainingModelPage.getTotal());
            uiPage.setPageSize(gdaiTrainingModelPage.getSize());
            uiPage.setPages(gdaiTrainingModelPage.getPages());
            uiPage.setPageNum(gdaiTrainingModelPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    } else {
        UiPage<GdaiTrainingModelVo> uiPage = new UiPage<>();
        List<String> desc = new ArrayList<>();
        desc.add("train_version");
        List<GdaiTrainingModelVo> list = new ArrayList<>();
        //拼装sql查询条件
        EntityWrapper<GdaiTrainingModel> wrapper = new EntityWrapper<>();
        wrapper.eq("algorithm_id", algorithmId).andNew().eq("share_flag", "1").or().eq("creator_id", userId);
        // 如果trainName非空，则添加模糊匹配条件
        if (StringUtils.isNotBlank(trainName)) {
            wrapper.like("train_name", trainName);
        }
        wrapper.orderDesc(desc);
        Page<GdaiTrainingModel> gdaiTrainingModelPage = gdaiTrainingModelService.selectPage(new Page<>(gdaiTrainingModelVo.getPageNumber(), gdaiTrainingModelVo.getPageCount()), wrapper);
        if (gdaiTrainingModelPage != null && gdaiTrainingModelPage.getRecords().size() > 0) {
            List<GdaiTrainingModel> records = gdaiTrainingModelPage.getRecords();
            for (GdaiTrainingModel gdaiTraining : records) {
                gdaiTrainingModelVo = new GdaiTrainingModelVo();
                BeanUtils.copyProperties(gdaiTraining, gdaiTrainingModelVo);
                Long creatorId = gdaiTraining.getCreatorId();
                User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
                if (userInfo != null) {
                    gdaiTrainingModelVo.setCreatorName(userInfo.getUsername());
                }
                list.add(gdaiTrainingModelVo);
            }
            uiPage.setTotal(gdaiTrainingModelPage.getTotal());
            uiPage.setPageSize(gdaiTrainingModelPage.getSize());
            uiPage.setPages(gdaiTrainingModelPage.getPages());
            uiPage.setPageNum(gdaiTrainingModelPage.getCurrent());
            uiPage.setList(list);
        }
        return RestResult.genSuccessResult(uiPage);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.util.CommonTools
com.eshore.gdai.trainingcenter.vo.GdaiTrainingModelVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiTrainingModelService gdaiTrainingModelService;
@Autowired
private HttpServletRequest request;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为queryAnnotationModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryAnnotationModel(GdaiTrainingModelVo gdaiTrainingModelVo) {
    log.info("GdaiTrainingModelServiceImpl.queryAnnotationModel params: [{}]}", JSON.toJSONString(gdaiTrainingModelVo));
    Long projectId = gdaiTrainingModelVo.getProjectId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    UiPage<GdaiTrainingModelVo> uiPage = new UiPage<>();
    List<String> desc = new ArrayList<>();
    desc.add("modify_time");
    List<GdaiTrainingModelVo> list = new ArrayList<>();
    Page<GdaiTrainingModel> gdaiTrainingModelPage = gdaiTrainingModelService.selectPage(new Page<>(gdaiTrainingModelVo.getPageNumber(), gdaiTrainingModelVo.getPageCount()), new EntityWrapper<GdaiTrainingModel>().eq("project_id", projectId).eq("train_source", "2").orderDesc(desc));
    if (gdaiTrainingModelPage != null && gdaiTrainingModelPage.getRecords().size() > 0) {
        List<GdaiTrainingModel> records = gdaiTrainingModelPage.getRecords();
        for (GdaiTrainingModel gdaiTraining : records) {
            gdaiTrainingModelVo = new GdaiTrainingModelVo();
            BeanUtils.copyProperties(gdaiTraining, gdaiTrainingModelVo);
            Long creatorId = gdaiTraining.getCreatorId();
            User userInfo = FeignServiceHelper.getUserInfoById(userClient, creatorId);
            if (userInfo != null) {
                gdaiTrainingModelVo.setCreatorName(userInfo.getUsername());
            }
            list.add(gdaiTrainingModelVo);
        }
        uiPage.setTotal(gdaiTrainingModelPage.getTotal());
        uiPage.setPageSize(gdaiTrainingModelPage.getSize());
        uiPage.setPages(gdaiTrainingModelPage.getPages());
        uiPage.setPageNum(gdaiTrainingModelPage.getCurrent());
        uiPage.setList(list);
    }
    return RestResult.genSuccessResult(uiPage);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.mapper.EntityWrapper
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.feign.helper.FeignServiceHelper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.vo.GdaiTrainingModelVo
org.springframework.beans.BeanUtils
org.springframework.stereotype.Service
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiTrainingModelService gdaiTrainingModelService;
@Resource
private UserClient userClient;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为queryTrainingModelById的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryTrainingModelById(GdaiTrainingModel gdaiTrainingModel) {
    log.info("GdaiTrainingModelServiceImpl.queryTrainingModelById params: [{}]", JSON.toJSONString(gdaiTrainingModel));
    Long trainId = gdaiTrainingModel.getTrainId();
    if (trainId == null) {
        return RestResult.genFailResult("训练ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    GdaiTrainingModel trainingModel;
    try {
        //修复水平越权问题
        trainingModel = checkGdaiTrainingModel(user, trainId, true);
    } catch (Exception e) {
        log.info("查询异常", e);
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult(trainingModel);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
org.springframework.stereotype.Service
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为queryTrainingModelList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<ApplicationVo> queryTrainingModelList(Long projectId) {
    try {
        return gdaiTrainingModelMapper.queryTrainingModelList(projectId);
    } catch (Exception e) {
        log.error(e.getMessage());
        return null;
    }
}
### 类导入的包
java.util.List
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为downloadModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult downloadModel(Long trainId, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiTrainingModelServiceImpl.downloadModel params: [{}]", JSON.toJSONString(trainId));
    if (trainId == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //根据模型ID查询该模型状态，若已完成训练则可以去对应路径下载训练完模型
        //修复水平越权问题
        GdaiTrainingModel trainingModel = checkGdaiTrainingModel(user, trainId, true);
        String status = trainingModel.getStatus();
        if (!"Succeeded".equals(status)) {
            return RestResult.genFailResult("训练尚未结束");
        }
        //获取保存模型的存储路径
        String modelSavePath = trainingModel.getModelSavePath();
        if (StringUtils.isBlank(modelSavePath)) {
            return RestResult.genFailResult("模型保存路径为空");
        }
        String fileName = "expect_" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(modelSavePath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为download的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult download(Long trainId, String subPath, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiTrainingModelServiceImpl.downloadModel params: [{}]", JSON.toJSONString(trainId));
    if (trainId == null) {
        return RestResult.genFailResult("参数不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //根据模型ID查询该模型状态，若已完成训练则可以去对应路径下载训练完模型
        //修复水平越权问题
        GdaiTrainingModel trainingModel = checkGdaiTrainingModel(user, trainId, true);
        String status = trainingModel.getStatus();
        if (!"Succeeded".equals(status)) {
            return RestResult.genFailResult("训练尚未结束");
        }
        String savePath = "";
        //获取保存模型的存储路径
        String context = trainingModel.getContext();
        if (StringUtils.isEmpty(context)) {
            return RestResult.genFailResult("下载路径为空");
        }
        JSONObject contextObj = JSON.parseObject(context);
        JSONArray volumes = contextObj.getJSONArray("volumes");
        if (volumes != null && volumes.size() > 0) {
            for (int i = 0; i < volumes.size(); i++) {
                JSONObject volume = volumes.getJSONObject(i);
                if (volume != null && Objects.equals(volume.getString("name"), "volume-0")) {
                    savePath = volume.getString("path");
                    break;
                }
            }
        }
        if (StringUtils.isBlank(savePath)) {
            return RestResult.genFailResult("下载路径为空");
        }
        if (StringUtils.isNotBlank(subPath)) {
            if (subPath.startsWith("/")) {
                savePath += subPath;
            } else {
                savePath += "/" + subPath;
            }
        }
        String fileName = "expect_" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(savePath, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
java.util.Objects
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为deleteFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult deleteFile(GdaiTrainingModelVo gdaiTrainingModelVo) {
    log.info("GdaiTrainingModelServiceImpl.deleteFile params: " + JSON.toJSONString(gdaiTrainingModelVo));
    //获取要删除的目录路径
    String targetPath = gdaiTrainingModelVo.getTargetPath();
    if (StringUtils.isBlank(targetPath)) {
        return RestResult.genFailResult("存放路径不能为空");
    }
    try {
        if (StringUtils.isNotBlank(targetPath)) {
            File file = FileUtils.getFile(targetPath);
            if (file.exists()) {
                FileUtil.deleteFile(file);
            }
        }
    } catch (Exception e) {
        return RestResult.genFailResult("删除异常");
    }
    return RestResult.genSuccessResult("删除成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为getResultUrl的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult getResultUrl(Long trainId, HttpServletResponse response, HttpServletRequest request) {
    log.info("GdaiTrainingModelServiceImpl.getResultUrl params: " + trainId);
    if (trainId == null) {
        return RestResult.genFailResult("训练ID不能为空");
    }
    //获取登录用户信息
    User user = (User) SessionUtils.getAttributeFromSession(request, UserConstant.USER, 0L);
    if (user == null) {
        return RestResult.genFailResult("登录用户信息为空");
    }
    try {
        //修复水平越权问题
        GdaiTrainingModel trainingModel = checkGdaiTrainingModel(user, trainId, true);
        String resultUrl = trainingModel.getResultUrl();
        if (StringUtils.isBlank(resultUrl)) {
            return RestResult.genFailResult("训练指标路径为空");
        }
        String fileName = "train_out" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        //设置response的header
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
        ZipUtil.toZip(resultUrl, response.getOutputStream(), true, true);
    } catch (Exception e) {
        log.info("下载异常", e);
        return RestResult.genFailResult("下载异常");
    }
    return RestResult.genSuccessResult("下载成功");
}
### 类导入的包
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.config.UserConstant
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.result.RestResult
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.util.ZipUtil
org.apache.commons.lang3.StringUtils
org.springframework.stereotype.Service
java.util.Date
### 类级别的变量
@Autowired
private HttpServletRequest request;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为queryByVersion的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public RestResult queryByVersion(GdaiTrainingModel gdaiTrainingModel) {
    log.info("GdaiTrainingModelServiceImpl.queryByVersion params: [{}]" + JSON.toJSONString(gdaiTrainingModel));
    Long projectId = gdaiTrainingModel.getProjectId();
    Long algorithmId = gdaiTrainingModel.getAlgorithmId();
    Long trainVersion = gdaiTrainingModel.getTrainVersion();
    Long creatorId = gdaiTrainingModel.getCreatorId();
    if (projectId == null) {
        return RestResult.genFailResult("项目ID不能为空");
    }
    if (algorithmId == null) {
        return RestResult.genFailResult("算法ID不能为空");
    }
    if (trainVersion == null) {
        return RestResult.genFailResult("版本号不能为空");
    }
    if (creatorId == null) {
        return RestResult.genFailResult("创建人不能为空");
    }
    try {
        GdaiTrainingModel trainingModel = gdaiTrainingModelMapper.selectOne(new GdaiTrainingModel(projectId, algorithmId, trainVersion, creatorId));
        if (trainingModel != null) {
            return RestResult.genFailResult("该版本号已存在");
        }
    } catch (Exception e) {
        return RestResult.genFailResult("查询异常");
    }
    return RestResult.genSuccessResult("查询成功");
}
### 类导入的包
com.alibaba.fastjson.JSON
com.baomidou.mybatisplus.service.impl.ServiceImpl
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.service.GdaiTrainingModelService
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为buildYmlContent的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildYmlContent(GdaiTrainingModel gdaiTrainingModel) throws Exception {
    try {
        //添加一些容器的初始参数到context中
        gdaiTrainingModel.buildContext();
        log.info("buildYmlContent GdaiTrainingModel context：\n" + gdaiTrainingModel.getContext());
        String ymlContent = YamlUtil.loadYaml(gdaiTrainingModel.getTrainYmlContent(), gdaiTrainingModel.getContext());
        gdaiTrainingModel.setTrainYmlContent(ymlContent);
        log.info("buildYmlContent GdaiTrainingModel 替换后模板:\n " + ymlContent);
    } catch (Exception ex) {
        log.error("create k8s deployment exception:", ex);
        throw new Exception(ex);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.util.YamlUtil
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为createJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    }
public void createJob(GdaiTrainingModel gdaiTrainingModel) throws Exception {
    try {
        String yamlContent = gdaiTrainingModel.getTrainYmlContent();
        JobBo serviceBo = jobService.createJob("", gdaiTrainingModel.getNameSpace(), yamlContent);
        //            V1Job job = YamlUtil.loadK8sObject(yamlContent, "Job", V1Job.class);
        //            V1Job v1Job = k8sClientOperator.createJob(job, gdaiTrainingModel.getNameSpace());
    } catch (Exception e) {
        throw e;
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.JobBo
com.eshore.gdai.trainingcenter.util.YamlUtil
io.kubernetes.client.openapi.models.V1Job
org.springframework.stereotype.Service
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private JobService jobService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类GdaiTrainingModelServiceImpl中有一个名为checkGdaiTrainingModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
 GdaiTrainingModel checkGdaiTrainingModel(User user, Long trainId, Boolean isCheckShareFlag) throws TrainginCenterException {
    GdaiTrainingModel trainingModel = gdaiTrainingModelMapper.selectById(trainId);
    if (trainingModel == null) {
        throw new TrainginCenterException("该记录不存在");
    } else {
        //判断登录用户角色
        //AI团队管理员角色
        boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
        //超级管理员角色
        boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
        //不是
        if (!(aiGroupAdminRole || superAdminRole)) {
            //不是本人的记录
            Long userId = user.getId();
            if (!userId.equals(trainingModel.getCreatorId())) {
                //共享记录
                if (isCheckShareFlag) {
                    if ("1".equals(trainingModel.getShareFlag())) {
                        Set<Long> projectIds = gdaiProjectService.queryProjectByUserId(userId);
                        //不是同一组或同一个项目
                        if (!projectIds.contains(trainingModel.getProjectId())) {
                            throw new TrainginCenterException("无权限执行该操作");
                        }
                    } else {
                        throw new TrainginCenterException("无权限执行该操作");
                    }
                } else {
                    throw new TrainginCenterException("无权限执行该操作");
                }
            }
        }
        return trainingModel;
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.entity.usercenter.User
com.chinatelecom.dcoos.common.exception.TrainginCenterException
com.chinatelecom.dcoos.common.utils.SessionUtils
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
org.springframework.stereotype.Service
java.util.Set
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为clusterList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo clusterList(String productCode, Integer pageIndex, Integer pageSize) throws IOException {
    JSONObject body = new JSONObject();
    body.put("systemId", systemId);
    body.put("productCode", productCode);
    if (pageIndex != null) {
        body.put("pageIndex", pageIndex);
    }
    if (pageSize != null) {
        body.put("pageSize", pageSize);
    }
    String result = AuthIcspUtils.requestIcsp("/ai/k8s/app/clusterList", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量
/**
 * 系统ID
 */
@Value("${icsp.systemId}")
private String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为nodeDetail的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo nodeDetail(String productCode, String clusterId, String nodeId) throws IOException {
    JSONObject body = new JSONObject();
    body.put("systemId", systemId);
    body.put("productCode", productCode);
    body.put("clusterId", clusterId);
    body.put("nodeId", nodeId);
    String result = AuthIcspUtils.requestIcsp("/ai/k8s/app/nodeDetail", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量
/**
 * 系统ID
 */
@Value("${icsp.systemId}")
private String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为resList的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo resList(String taskReqId, String productCode, Integer pageIndex, Integer pageSize) throws IOException {
    JSONObject body = new JSONObject();
    body.put("taskReqId", taskReqId);
    body.put("systemId", systemId);
    body.put("productCode", productCode);
    if (pageIndex != null) {
        body.put("pageIndex", pageIndex);
    }
    if (pageSize != null) {
        body.put("pageSize", pageSize);
    }
    String result = AuthIcspUtils.requestIcsp("/ai/k8s/app/resList", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量
/**
 * 系统ID
 */
@Value("${icsp.systemId}")
private String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为instNumUpdate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo instNumUpdate(String replicas, String taskReqId, String taskCode, String productCode, String userId, String tenantId) throws IOException {
    JSONObject body = new JSONObject();
    body.put("replicas", replicas);
    body.put("taskReqId", taskReqId);
    body.put("taskCode", taskCode);
    body.put("systemId", systemId);
    body.put("productCode", productCode);
    body.put("userId", userId);
    body.put("tenantId", tenantId);
    String result = AuthIcspUtils.requestIcsp("/api/v1/ai/instNum/update", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量
/**
 * 系统ID
 */
@Value("${icsp.systemId}")
private String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为logQuery的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo logQuery(String taskReqId, String podName, String namespace, String productCode, String userId, String tenantId, String taskCode) throws IOException {
    JSONObject body = new JSONObject();
    body.put("taskReqId", taskReqId);
    body.put("podName", podName);
    body.put("namespace", namespace);
    body.put("systemId", systemId);
    body.put("productCode", productCode);
    body.put("userId", userId);
    body.put("tenantId", tenantId);
    body.put("taskCode", taskCode);
    String result = AuthIcspUtils.requestIcsp("/api/v1/ai/log/query", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量
/**
 * 系统ID
 */
@Value("${icsp.systemId}")
private String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为deleteTask2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo deleteTask2(String taskCode, String taskReqId) throws IOException {
    JSONObject body = new JSONObject();
    body.put("taskCode", taskCode);
    body.put("taskReqId", taskReqId);
    String result = AuthIcspUtils.requestIcsp("/api/v1/ai/deleteTask2", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为taskQuery的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo taskQuery(String taskReqId, String taskCode) throws IOException {
    JSONObject body = new JSONObject();
    body.put("taskReqId", taskReqId);
    body.put("taskCode", taskCode);
    String result = AuthIcspUtils.requestIcsp("/api/v1/ai/task/query", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.service.impl下的类IcspServiceImpl中有一个名为queryTaskSummaryInNamespace的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public IcspResultVo queryTaskSummaryInNamespace(String clusterId, String namespace, String clusterName, String taskReqId) throws IOException {
    JSONObject body = new JSONObject();
    body.put("clusterId", clusterId);
    body.put("namespace", namespace);
    body.put("clusterName", clusterName);
    body.put("taskReqId", taskReqId);
    body.put("systemId", systemId);
    String result = AuthIcspUtils.requestIcsp("/api/v1/ai/queryTaskSummaryInNamespace", body);
    return JSON.parseObject(result, IcspResultVo.class);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.util.AuthIcspUtils
com.eshore.gdai.trainingcenter.vo.IcspResultVo
### 类级别的变量
/**
 * 系统ID
 */
@Value("${icsp.systemId}")
private String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为checkOrderPending的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 定时查询待处理订单(5秒一次)
     */
public void checkOrderPending() {
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            //查询订单表中订单状态为:1-待处理的数据
            List<GdaiAlgorithmOrder> gdaiAlgorithmOrderList = gdaiAlgorithmOrderMapper.queryAlgorithmOrderList(new GdaiAlgorithmOrder("1"));
            if (gdaiAlgorithmOrderList != null && gdaiAlgorithmOrderList.size() > 0) {
                for (GdaiAlgorithmOrder algorithmOrder : gdaiAlgorithmOrderList) {
                    //获取订单ID
                    Long orderId = algorithmOrder.getOrderId();
                    //订单类型：1-模型部署
                    String orderType = algorithmOrder.getOrderType();
                    //操作类型：1-新增，2-变更，3-退订，4-扩缩容，5-启动（解冻），6-停止（冻结）
                    String orderOperation = algorithmOrder.getOrderOperation();
                    //获取业务内容
                    JSONObject orderContent = algorithmOrder.getOrderContent();
                    //部署资源池：1-本地资源池，2-边缘云资源池，3-集团资源池
                    String orderDeployPool = algorithmOrder.getOrderDeployPool();
                    //获取多云管任务请求ID
                    String taskReqId = orderContent.getString("taskReqId");
                    //获取本地资源池部署的ID
                    String servingId = orderContent.getString("servingId");
                    //获取接口调用方送的业务ID
                    String crmOrderId = algorithmOrder.getCrmOrderId();
                    //根据部署资源池确定送那个业务ID
                    String bizId = "";
                    if (orderDeployPool.equals("1")) {
                        bizId = servingId;
                    } else if (orderDeployPool.equals("2")) {
                        bizId = taskReqId;
                    } else if (orderDeployPool.equals("3")) {
                        //集团
                    }
                    //扫到待处理的订单之后将订单类型置为:2-处理中
                    gdaiAlgorithmOrderMapper.updateById(new GdaiAlgorithmOrder(orderId, "2", "处理中", new Date()));
                    //模型部署
                    if (orderType.equals("1")) {
                        if (orderOperation.equals("1")) {
                            //新增
                            addDeployModel(orderId, bizId, orderDeployPool, orderContent);
                        } else if (orderOperation.equals("2")) {
                            //变更
                            updateDeployModel(orderId, bizId, orderDeployPool, orderContent);
                        } else if (orderOperation.equals("3")) {
                            //退订
                            deleteDeployModel(orderId, bizId, orderDeployPool, orderContent);
                        } else if (orderOperation.equals("4")) {
                            //扩缩容
                            expandAndShrinkPod(orderId, bizId, crmOrderId, orderDeployPool, orderContent);
                        } else if (orderOperation.equals("5")) {
                            //启动（解冻）
                        } else if (orderOperation.equals("6")) {
                            //停止（冻结）
                        } else {
                            log.info("订单操作类型不匹配：{}", orderOperation);
                        }
                    } else {
                        log.info("订单类型不匹配：{}", orderType);
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("处理订单异常：", e);
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为checkOrderProcessing的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 定时查询处理中订单(10分钟一次)
     */
public void checkOrderProcessing() {
    Long orderId = null;
    String bizId = null;
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            //查询订单表中订单状态为:2-处理中的数据
            List<GdaiAlgorithmOrder> gdaiAlgorithmOrderList = gdaiAlgorithmOrderMapper.queryAlgorithmOrderList(new GdaiAlgorithmOrder("2"));
            if (gdaiAlgorithmOrderList != null && gdaiAlgorithmOrderList.size() > 0) {
                for (GdaiAlgorithmOrder algorithmOrder : gdaiAlgorithmOrderList) {
                    //获取订单部署资源池类型：1-本地资源池，2-边缘云资源池，3-集团资源池（使用不同部署资源池的接口返回接口不同，需分情况处理）
                    String orderDeployPool = algorithmOrder.getOrderDeployPool();
                    //通过前端生态录入选择的部署资源池（包含多云管资源池），新增部署成功后，会像部署表新增记录
                    if (orderDeployPool.equals("1") || orderDeployPool.equals("2")) {
                        //本地资源池
                        //获取创建时间
                        Date createTime = algorithmOrder.getCreateTime();
                        //获取订单ID
                        orderId = algorithmOrder.getOrderId();
                        //获取任务ID（多云管对应的是新增时的taskReqId值，本地资源池部署对应值是servingId值）
                        bizId = algorithmOrder.getBizId();
                        //获取订单操作类型：1-新增，2-变更，3-退订，4-扩缩容，5-启动（解冻），6-停止（冻结）
                        String orderOperation = algorithmOrder.getOrderOperation();
                        //根据业务ID查询部署状态（由于是本地资源池部署，所以这里的bizId对应servingId值）
                        GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(Long.valueOf(bizId));
                        if (gdaiModelDeploy == null) {
                            //查询失败，订单状态置为处理失败，调接口回单
                            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "本地部署查询为空", bizId, new Date()));
                        } else {
                            //获取部署状态，判断是否部署成功
                            String status = gdaiModelDeploy.getStatus();
                            String serviceUrl = gdaiModelDeploy.getServiceUrl();
                            Long distanceMin = DateUtil.getDistanceMin(createTime, new Date());
                            if ("4".equals(orderOperation)) {
                                //获取orderContent中的replicas值，与实际部署的实例数量比较，如果不一致，则订单状态置为处理失败。如果一致，则订单状态置为成功，调接口回单
                                JSONObject orderContent = algorithmOrder.getOrderContent();
                                if (orderContent != null) {
                                    //获取实例数量
                                    Long replicas = orderContent.getLong("replicas");
                                    //获取实际部署的实例数量
                                    Integer readyReplicas = gdaiModelDeploy.getReadyReplicas();
                                    if (!(replicas.longValue() == readyReplicas.longValue())) {
                                        if (distanceMin >= 20) {
                                            //更新订单状态置为失败，调接口回单失败原因
                                            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "服务部署超时", bizId, new Date()));
                                        }
                                    } else {
                                        //获取context大字段中的active字段，如果为1则需要等待所有容器都处于激活状态才能回单
                                        String context = gdaiModelDeploy.getContext();
                                        JSONObject jsonContext = JSON.parseObject(context);
                                        String active = jsonContext.getString("active");
                                        if ("1".equals(active)) {
                                            //更新结束查询已经激活的服务数量是否与期望副本数一直，如果一致则调回单接口回单
                                            Long projectId = gdaiModelDeploy.getProjectId();
                                            Integer replicas1 = gdaiModelDeploy.getReplicas();
                                            int activeCount = gdaiPodMapper.queryActiveCount(projectId, Long.valueOf(bizId));
                                            log.info("订单部署服务数量：{},实际部署服务激活数量：{}", replicas1, activeCount);
                                            if (activeCount == replicas1) {
                                                //解析返回的url
                                                String url = parseJsonArray(serviceUrl);
                                                if ("S2R".equals(status) && StringUtils.isNotBlank(url)) {
                                                    //查询成功，订单状态置为成功，调接口回单
                                                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "3", "处理成功", bizId, new Date(), url));
                                                }
                                            } else {
                                                log.info("订单部署服务暂未全部激活，orderId，servingId: {},{}", orderId, bizId);
                                            }
                                        } else {
                                            //解析返回的url
                                            String url = parseJsonArray(serviceUrl);
                                            if ("S2R".equals(status) && StringUtils.isNotBlank(url)) {
                                                //查询成功，订单状态置为成功，调接口回单
                                                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "3", "处理成功", bizId, new Date(), url));
                                            }
                                        }
                                    }
                                }
                            } else {
                                //解析返回的url
                                String url = parseJsonArray(serviceUrl);
                                if ("S2R".equals(status) && StringUtils.isNotBlank(url)) {
                                    //查询成功，订单状态置为成功，调接口回单
                                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "3", "处理成功", bizId, new Date(), url));
                                } else {
                                    //获取任务创建时间，判断是否超过20分钟，如果超过20分钟强制置为失败
                                    if (distanceMin >= 20) {
                                        //更新订单状态置为失败，调接口回单失败原因
                                        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "服务部署超时", bizId, new Date()));
                                    }
                                }
                            }
                        }
                    } else //                        else if (orderDeployPool.equals("2")) {
                    //                            //边缘云资源池
                    //                            //获取创建时间
                    //                            Date createTime = algorithmOrder.getCreateTime();
                    //                            //获取订单ID
                    //                            orderId = algorithmOrder.getOrderId();
                    //                            //获取业务ID
                    //                            bizId = algorithmOrder.getBizId();
                    //
                    //                            //获取操作标识
                    //                            String orderOperation = algorithmOrder.getOrderOperation();
                    //                            IcspResultVo taskQueryResultVo;
                    //                            //调查询接口的taskReqId，没有业务含义，以90开头
                    //                            String taskReqId = "90" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
                    //                            //调任务调度结果信息查询接口
                    //                            String taskCode;
                    //                            if (orderOperation.equals("2") || orderOperation.equals("4")) {
                    //                                JSONObject orderContent = algorithmOrder.getOrderContent();
                    //                                taskCode = orderContent.getString("taskCode");
                    //                                //如果是修改或扩缩容操作的记录，获取任务新增部署时的taskReqId（taskCode）
                    //                                taskQueryResultVo = icspService.taskQuery(taskReqId, taskCode);
                    //                            } else {
                    //                                //调任务调度结果信息查询接口
                    //                                taskCode = bizId;
                    //                                taskQueryResultVo = icspService.taskQuery(taskReqId, taskCode);
                    //                            }
                    //
                    //                            if (taskQueryResultVo == null) {
                    //                                //调任务调度结果信息查询失败，更新订单状态置为失败，调接口回单失败原因
                    //                                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "任务调度结果信息查询接口异常", bizId, new Date()));
                    //                            }
                    //                            String code = taskQueryResultVo.getCode();
                    //                            String message = taskQueryResultVo.getMessage();
                    //                            if (code.equals("0")) {
                    //                                //调任务调度结果信息查询成功，订单状态置为成功
                    //                                Object data = taskQueryResultVo.getData();
                    //                                JSONObject jsonObject = JSON.parseObject(data.toString());
                    //                                String url = jsonObject.getString("url");
                    //                                //查询成功，订单状态置为成功，调接口回单
                    //                                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "3", "处理成功", bizId, new Date(), url, taskCode));
                    //                            } else if (code.equals("-1")) {
                    //                                log.info("正在部署中，请10分钟后查询部署结果");
                    //                                //获取任务创建时间，判断是否超过20分钟，如果超过20分钟强制置为失败
                    //                                Long distanceMin = DateUtil.getDistanceMin(createTime, new Date());
                    //                                if (distanceMin >= 20) {
                    //                                    //更新订单状态置为失败，调接口回单失败原因
                    //                                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "服务部署超时", bizId, new Date()));
                    //                                }
                    //                            } else {
                    //                                //调任务调度结果信息查询失败，订单状态置为失败，调接口回单失败原因
                    //                                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", message, bizId, new Date()));
                    //                            }
                    //                        }
                    if (orderDeployPool.equals("3")) {
                        //集团资源池
                    } else {
                        log.info("订单部署资源池不匹配：{}", orderDeployPool);
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("查询订单处理结果异常：", e);
        //调任务调度结果信息查询异常，订单状态置为异常，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.apache.commons.lang3.StringUtils
org.springframework.beans.factory.annotation.Value
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiAlgorithmOrderMapper gdaiAlgorithmOrderMapper;
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private IcspService icspService;
@Resource
private GdaiPodMapper gdaiPodMapper;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为addDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 新增模型部署
     *
     * @param orderId
     * @param orderDeployPool
     * @param orderContent
     */
public void addDeployModel(Long orderId, String bizId, String orderDeployPool, JSONObject orderContent) {
    try {
        if (orderDeployPool.equals("1")) {
            //使用本地资源池部署
            GdaiModelServingAddVo gdaiModelServingAddVo = new GdaiModelServingAddVo();
            gdaiModelServingAddVo.setServingName(orderContent.getString("servingName"));
            gdaiModelServingAddVo.setServingType(orderContent.getString("servingType"));
            gdaiModelServingAddVo.setServingDesc(orderContent.getString("servingDesc"));
            gdaiModelServingAddVo.setShareFlag(orderContent.getString("shareFlag"));
            gdaiModelServingAddVo.setCreatorId(orderContent.getLongValue("creatorId"));
            gdaiModelServingAddVo.setProjectId(orderContent.getLongValue("projectId"));
            GdaiModelDeployVo gdaiModelDeployVo = new GdaiModelDeployVo();
            gdaiModelDeployVo.setDeployName(orderContent.getString("deployName"));
            gdaiModelDeployVo.setImageId(orderContent.getLongValue("imageId"));
            gdaiModelDeployVo.setHarborImageId(orderContent.getLongValue("harborImageId"));
            gdaiModelDeployVo.setCommandAndArgs(orderContent.getString("commandAndArgs"));
            gdaiModelDeployVo.setRemarks(orderContent.getString("remarks"));
            gdaiModelDeployVo.setShareFlag(orderContent.getString("shareFlag"));
            gdaiModelDeployVo.setCreatorId(orderContent.getLongValue("creatorId"));
            gdaiModelDeployVo.setProjectId(orderContent.getLongValue("projectId"));
            gdaiModelDeployVo.setProcessUnitType(orderContent.getString("processUnitType"));
            gdaiModelDeployVo.setCore(orderContent.getString("core"));
            gdaiModelDeployVo.setMemorySize(orderContent.getString("memorySize"));
            gdaiModelDeployVo.setGpuSize(orderContent.getString("gpuSize"));
            gdaiModelServingAddVo.setGdaiModelDeploy(gdaiModelDeployVo);
            log.info(gdaiModelServingAddVo.toString());
            addLocalDeployModel(orderId, bizId, gdaiModelServingAddVo);
        } else if (orderDeployPool.equals("2")) {
            //使用多云管资源池部署
            addIcspDeployModel(orderId, bizId, orderContent);
        } else if (orderDeployPool.equals("3")) {
            //使用集团资源池部署
        }
    } catch (Exception e) {
        log.info("新增模型部署异常:", e.getMessage());
        //模型部署异常，订单状态置为异常，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
com.eshore.gdai.trainingcenter.vo.GdaiModelServingAddVo
org.springframework.beans.factory.annotation.Value
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为updateDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 变更模型部署
     *
     * @param orderId
     * @param orderDeployPool
     * @param orderContent
     */
public void updateDeployModel(Long orderId, String bizId, String orderDeployPool, JSONObject orderContent) {
    try {
        if (orderDeployPool.equals("1")) {
            //变更本地资源池部署
            GdaiModelServingAddVo gdaiModelServingAddVo = new GdaiModelServingAddVo();
            gdaiModelServingAddVo.setServingId(orderContent.getLongValue("servingId"));
            gdaiModelServingAddVo.setServingName(orderContent.getString("servingName"));
            gdaiModelServingAddVo.setServingType(orderContent.getString("servingType"));
            gdaiModelServingAddVo.setServingDesc(orderContent.getString("servingDesc"));
            gdaiModelServingAddVo.setShareFlag(orderContent.getString("shareFlag"));
            gdaiModelServingAddVo.setCreatorId(orderContent.getLongValue("creatorId"));
            gdaiModelServingAddVo.setProjectId(orderContent.getLongValue("projectId"));
            GdaiModelDeployVo gdaiModelDeployVo = new GdaiModelDeployVo();
            gdaiModelDeployVo.setDeployName(orderContent.getString("deployName"));
            gdaiModelDeployVo.setImageId(orderContent.getLongValue("imageId"));
            gdaiModelDeployVo.setHarborImageId(orderContent.getLongValue("harborImageId"));
            gdaiModelDeployVo.setCommandAndArgs(orderContent.getString("commandAndArgs"));
            gdaiModelDeployVo.setRemarks(orderContent.getString("remarks"));
            gdaiModelDeployVo.setShareFlag(orderContent.getString("shareFlag"));
            gdaiModelDeployVo.setCreatorId(orderContent.getLongValue("creatorId"));
            gdaiModelDeployVo.setProjectId(orderContent.getLongValue("projectId"));
            gdaiModelDeployVo.setProcessUnitType(orderContent.getString("processUnitType"));
            gdaiModelDeployVo.setCore(orderContent.getString("core"));
            gdaiModelDeployVo.setMemorySize(orderContent.getString("memorySize"));
            gdaiModelDeployVo.setGpuSize(orderContent.getString("gpuSize"));
            gdaiModelServingAddVo.setGdaiModelDeploy(gdaiModelDeployVo);
            log.info(gdaiModelServingAddVo.toString());
            updateLocalDeployModel(orderId, orderContent.getString("servingId"), gdaiModelServingAddVo);
        } else if (orderDeployPool.equals("2")) {
            //变更多云管资源池部署
            updateIcspDeployModel(orderId, bizId, orderContent);
        } else if (orderDeployPool.equals("3")) {
            //变更集团资源池部署
        }
    } catch (Exception e) {
        log.info("变更模型部署异常:", e.getMessage());
        //模型部署异常，订单状态置为异常，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
com.eshore.gdai.trainingcenter.vo.GdaiModelServingAddVo
org.springframework.beans.factory.annotation.Value
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为deleteDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除模型部署
     *
     * @param orderId
     * @param orderDeployPool
     * @param orderContent
     */
public void deleteDeployModel(Long orderId, String bizId, String orderDeployPool, JSONObject orderContent) {
    try {
        if (orderDeployPool.equals("1")) {
            //删除本地资源池部署
            GdaiModelServingVo gdaiModelServingVo = new GdaiModelServingVo();
            gdaiModelServingVo.setServingId(orderContent.getLongValue("servingId"));
            gdaiModelServingVo.setProjectId(orderContent.getLongValue("projectId"));
            log.info(gdaiModelServingVo.toString());
            deleteLocalDeployModel(orderId, orderContent.getString("servingId"), gdaiModelServingVo);
        } else if (orderDeployPool.equals("2")) {
            //删除多云管资源池部署
            deleteIcspDeployModel(orderId, bizId, orderContent);
        } else if (orderDeployPool.equals("3")) {
            //删除集团资源池部署
        }
    } catch (Exception e) {
        log.info("删除模型部署异常:", e.getMessage());
        //模型部署异常，订单状态置为异常，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.GdaiModelServingVo
org.springframework.beans.factory.annotation.Value
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为expandAndShrinkPod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 扩缩容容器个数
     *
     * @param orderId
     * @param bizId
     * @param crmOrderId
     * @param orderDeployPool
     * @param orderContent
     */
public void expandAndShrinkPod(Long orderId, String bizId, String crmOrderId, String orderDeployPool, JSONObject orderContent) {
    try {
        if (orderDeployPool.equals("1")) {
            //扩缩容本地资源池部署容器个数
            String replicas = orderContent.getString("replicas");
            expandAndShrinkLocalPod(orderId, bizId, crmOrderId, Long.valueOf(replicas));
        } else if (orderDeployPool.equals("2")) {
            //扩缩容多云管资源池容器个数
            expandAndShrinkIcspPod(orderId, bizId, crmOrderId, orderContent);
        } else if (orderDeployPool.equals("3")) {
            //扩缩容集团资源池部署容器个数
        }
    } catch (Exception e) {
        log.info("扩缩容容器异常:", e.getMessage());
        //扩缩容容器异常，订单状态置为异常，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为addLocalDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 新增本地资源池部署
     *
     * @param gdaiModelServingAddVo
     * @return
     */
public void addLocalDeployModel(Long orderId, String bizId, GdaiModelServingAddVo gdaiModelServingAddVo) {
    log.info("GdaiAlgorithmOrderTask.addLocalDeployModel params: [{}]", JSON.toJSONString(gdaiModelServingAddVo));
    try {
        //调本地资源池部署服务
        RestResult result = gdaiModelServingService.add(gdaiModelServingAddVo);
        if (result != null) {
            String code = result.getCode();
            if (code.equals("200")) {
                GdaiModelServing gdaiModelServing = (GdaiModelServing) result.getData();
                //同步部署ID至bizId字段
                GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
                gdaiAlgorithmOrder.setOrderId(orderId);
                gdaiAlgorithmOrder.setBizId(gdaiModelServing.getServingId().toString());
                gdaiAlgorithmOrder.setModifyTime(new Date());
                gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
            } else {
                //本地部署异常，订单状态置为异常，调接口回单失败原因
                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", result.getMessage(), bizId, new Date()));
            }
        }
    } catch (Exception e) {
        log.info("本地部署异常:", e);
        //本地部署异常，订单状态置为异常，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private GdaiModelServingService gdaiModelServingService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为addIcspDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 新增多云管资源池部署
     *
     * @param orderId
     * @param jsonObject
     */
public void addIcspDeployModel(Long orderId, String bizId, JSONObject jsonObject) {
    log.info("GdaiAlgorithmOrderTask.addIcspDeployModel params: [{}]", JSON.toJSONString(jsonObject));
    //调多云管资源池部署服务
    try {
        //1.获取业务ID同步至订单表
        if (jsonObject == null) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "业务参数为空", bizId, new Date()));
        }
        if (!jsonObject.containsKey("taskReqId")) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId不存在", bizId, new Date()));
        }
        String taskReqId = jsonObject.getString("taskReqId");
        if (StringUtils.isBlank(taskReqId)) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId值为空", bizId, new Date()));
        }
        //同步业务ID到订单表
        GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
        gdaiAlgorithmOrder.setOrderId(orderId);
        gdaiAlgorithmOrder.setBizId(taskReqId);
        gdaiAlgorithmOrder.setModifyTime(new Date());
        gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
        //2.调新增任务接口
        IcspResultVo icspResultVo = icspService.deployByImage(jsonObject);
        if (icspResultVo == null) {
            //新增任务失败，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "新增任务接口异常", bizId, new Date()));
        }
        String code = icspResultVo.getCode();
        String message = icspResultVo.getMessage();
        if (!code.equals("0")) {
            //新增任务失败，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", message, bizId, new Date()));
        }
    } catch (Exception e) {
        log.info("多云管部署异常:", e);
        //调接口回单失败原因，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private IcspService icspService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为updateLocalDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 修改本地资源池部署
     *
     * @param orderId
     * @param gdaiModelServingAddVo
     */
public void updateLocalDeployModel(Long orderId, String bizId, GdaiModelServingAddVo gdaiModelServingAddVo) {
    log.info("GdaiAlgorithmOrderTask.updateLocalDeployModel params: [{}]", JSON.toJSONString(gdaiModelServingAddVo));
    //修改本地资源池部署
    try {
        RestResult result = gdaiModelServingService.replace(gdaiModelServingAddVo);
        if (result != null) {
            //同步部署ID至bizId字段
            GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
            gdaiAlgorithmOrder.setOrderId(orderId);
            gdaiAlgorithmOrder.setBizId(bizId);
            gdaiAlgorithmOrder.setModifyTime(new Date());
            gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
            String code = result.getCode();
            if (!code.equals("200")) {
                //修改本地部署异常，订单状态置为异常，调接口回单失败原因
                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", result.getMessage(), bizId, new Date()));
            }
        }
    } catch (Exception e) {
        log.info("修改本地部署异常:", e);
        //调接口回单失败原因，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private GdaiModelServingService gdaiModelServingService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为updateIcspDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 修改多云管资源池部署
     *
     * @param orderId
     * @param jsonObject
     */
public void updateIcspDeployModel(Long orderId, String bizId, JSONObject jsonObject) {
    log.info("GdaiAlgorithmOrderTask.updateIcspDeployModel params: [{}]", JSON.toJSONString(jsonObject));
    //修改多云管资源池部署
    try {
        //1.获取业务ID同步至订单表
        if (jsonObject == null) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "业务参数为空", bizId, new Date()));
        }
        if (!jsonObject.containsKey("taskReqId")) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId不存在", bizId, new Date()));
        }
        String taskReqId = jsonObject.getString("taskReqId");
        if (StringUtils.isBlank(taskReqId)) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId值为空", bizId, new Date()));
        }
        //同步业务ID到订单表
        GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
        gdaiAlgorithmOrder.setOrderId(orderId);
        gdaiAlgorithmOrder.setBizId(taskReqId);
        gdaiAlgorithmOrder.setModifyTime(new Date());
        gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
        //2.调修改任务接口
        IcspResultVo icspResultVo = icspService.updateTask2(jsonObject);
        if (icspResultVo == null) {
            //修改任务失败，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "修改任务接口异常", bizId, new Date()));
        }
        String code = icspResultVo.getCode();
        String message = icspResultVo.getMessage();
        if (!code.equals("0")) {
            //修改任务失败，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", message, bizId, new Date()));
        }
    } catch (Exception e) {
        log.info("修改多云管部署异常:", e);
        //调接口回单失败原因，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private IcspService icspService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为deleteLocalDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除本地资源池部署
     *
     * @param orderId
     * @param gdaiModelServingVo
     */
public void deleteLocalDeployModel(Long orderId, String bizId, GdaiModelServingVo gdaiModelServingVo) {
    log.info("GdaiAlgorithmOrderTask.deleteLocalDeployModel params: [{}]", JSON.toJSONString(gdaiModelServingVo));
    //删除本地资源池部署
    try {
        RestResult result = gdaiModelServingService.delete(gdaiModelServingVo);
        if (result != null) {
            //同步部署ID至bizId字段
            GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
            gdaiAlgorithmOrder.setOrderId(orderId);
            gdaiAlgorithmOrder.setBizId(bizId);
            gdaiAlgorithmOrder.setModifyTime(new Date());
            gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
            String code = result.getCode();
            String message = result.getMessage();
            if (code.equals("200")) {
                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "3", "处理成功", bizId, new Date()));
            } else {
                //删除任务失败，订单状态置为失败，调接口回单失败原因
                gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", message, bizId, new Date()));
            }
        }
    } catch (Exception e) {
        log.info("删除本地部署异常:", e);
        //调接口回单失败原因，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private GdaiModelServingService gdaiModelServingService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为deleteIcspDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除多云管资源池部署
     *
     * @param orderId
     * @param jsonObject
     */
public void deleteIcspDeployModel(Long orderId, String bizId, JSONObject jsonObject) {
    log.info("GdaiAlgorithmOrderTask.deleteIcspDeployModel params: [{}]", JSON.toJSONString(jsonObject));
    //修改多云管资源池部署
    try {
        //1.获取业务ID同步至订单表
        if (jsonObject == null) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "业务参数为空", bizId, new Date()));
        }
        if (!jsonObject.containsKey("taskReqId")) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId不存在", bizId, new Date()));
        }
        String taskReqId = jsonObject.getString("taskReqId");
        if (StringUtils.isBlank(taskReqId)) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId为空", bizId, new Date()));
        }
        if (!jsonObject.containsKey("taskCode")) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskCode不存在", bizId, new Date()));
        }
        String taskCode = jsonObject.getString("taskCode");
        if (StringUtils.isBlank(taskCode)) {
            //参数异常，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskCode为空", bizId, new Date()));
        }
        //同步业务ID到订单表
        GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
        gdaiAlgorithmOrder.setOrderId(orderId);
        gdaiAlgorithmOrder.setBizId(taskReqId);
        gdaiAlgorithmOrder.setModifyTime(new Date());
        gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
        //2.调删除任务接口
        IcspResultVo icspResultVo = icspService.deleteTask2(taskCode, taskReqId);
        if (icspResultVo == null) {
            //删除任务失败，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "删除任务接口异常", bizId, new Date()));
        }
        String code = icspResultVo.getCode();
        String message = icspResultVo.getMessage();
        if (code.equals("0")) {
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "3", "处理成功", bizId, new Date()));
        } else {
            //删除任务失败，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", message, bizId, new Date()));
        }
    } catch (Exception e) {
        log.info("删除多云管部署异常:", e);
        //调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private IcspService icspService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为expandAndShrinkLocalPod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 扩缩容本地资源池部署容器个数
     *
     * @param orderId
     * @param bizId
     * @param instances
     */
public void expandAndShrinkLocalPod(Long orderId, String bizId, String crmOrderId, Long instances) {
    log.info("GdaiAlgorithmOrderTask.expandAndShrinkLocalPod params: [{}],[{}],[{}],[{}]", orderId, bizId, crmOrderId, instances);
    //扩缩容本地资源池部署容器个数
    try {
        //同步业务ID到订单表
        GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
        gdaiAlgorithmOrder.setOrderId(orderId);
        gdaiAlgorithmOrder.setBizId(bizId);
        gdaiAlgorithmOrder.setModifyTime(new Date());
        gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
        //调扩缩容接口前根据部署ID查询部署信息，如果查询部署信息失败，订单状态置为失败，调接口回单失败原因
        GdaiModelDeploy gdaiModelDeploy = gdaiModelDeployMapper.selectCurrentDeploy(Long.valueOf(bizId));
        if (gdaiModelDeploy == null) {
            //未查询到部署实例，订单状态置为失败，调接口回单失败原因
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "部署信息为空", crmOrderId, new Date()));
        }
        log.info("查询部署信息:[{}]", JSON.toJSONString(gdaiModelDeploy));
        log.info("需扩容数:[{}]", instances);
        gdaiModelDeployService.scaleDeployment(gdaiModelDeploy, instances);
    } catch (Exception e) {
        log.info("本地资源池扩缩容异常:", e);
        //调接口回单失败原因，调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), crmOrderId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为expandAndShrinkIcspPod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 扩缩容多云管资源池部署容器个数
     *
     * @param orderId
     * @param bizId
     * @param crmOrderId
     * @param jsonObject
     */
public void expandAndShrinkIcspPod(Long orderId, String bizId, String crmOrderId, JSONObject jsonObject) {
    log.info("GdaiAlgorithmOrderTask.expandAndShrinkIcspPod params: [{}],[{}],[{}],[{}]", orderId, bizId, crmOrderId, JSON.toJSONString(jsonObject));
    //扩缩容多云管资源池部署容器个数
    try {
        //根据servingType、areaCode、orderAlgorithmId查询是否存在服务记录
        String servingType = jsonObject.getString("servingType");
        String areaCode = jsonObject.getString("areaCode");
        String orderAlgorithmId = jsonObject.getString("orderAlgorithmId");
        RestResult restResult = gdaiModelServingService.thirdPartyQueryIcspInfo(new GdaiModelServing(servingType, areaCode, orderAlgorithmId));
        if (restResult != null && restResult.getData() != null) {
            //如果存在则直接拿taskCode调多云管扩缩容接口
            String code = restResult.getCode();
            if ("201".equals(code)) {
                //201表示该地区多云管未部署该算法，所以返回多云管部署在省中心节点的信息，直接调新增接口（直接设置副本数）
                Object data = restResult.getData();
                String dataStr = JSON.toJSONString(data);
                GdaiModelServingAddVo gdaiModelServingAddVo = JSON.parseObject(dataStr, GdaiModelServingAddVo.class);
                //对省中心节点部署参数进行个别值替换修改，修改为地市节点的参数
                String creatorId = jsonObject.getString("creatorId");
                gdaiModelServingAddVo.setCreatorId(Long.parseLong(creatorId));
                gdaiModelServingAddVo.setModifierId(Long.parseLong(creatorId));
                GdaiModelDeployVo gdaiModelDeploy = gdaiModelServingAddVo.getGdaiModelDeploy();
                //替换context的值
                String context = gdaiModelDeploy.getContext();
                JSONObject jsonContext = JSON.parseObject(context);
                //获取replicas需要扩缩容的副本数
                String replicas = jsonObject.getString("replicas");
                //修改jsonContext中instances的值为replicas
                jsonContext.put("instances", replicas);
                //修改jsonContext中areaCode的值
                jsonContext.put("areaCode", areaCode);
                jsonContext.remove("icsp");
                gdaiModelDeploy.setContext(jsonContext.toJSONString());
                //替换serviceUrl的值
                String serviceUrl = gdaiModelDeploy.getServiceUrl();
                JSONArray jsonArray = JSONArray.parseArray(serviceUrl);
                // 遍历JSONArray中的每个JSONObject，并移除url键
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject jsonObj = jsonArray.getJSONObject(i);
                    jsonObj.remove("url");
                }
                gdaiModelDeploy.setServiceUrl(jsonArray.toJSONString());
                gdaiModelServingAddVo.setGdaiModelDeploy(gdaiModelDeploy);
                Date now = new Date();
                gdaiModelServingAddVo.setCreateTime(now);
                gdaiModelServingAddVo.setModifyTime(now);
                RestResult addResult = gdaiModelServingService.add(gdaiModelServingAddVo);
                if (addResult == null || addResult.getData() == null) {
                    //新增失败，更新订单状态为失败，回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", addResult.getMessage(), bizId, new Date()));
                } else {
                    Object dataObj = restResult.getData();
                    String dataObjStr = JSON.toJSONString(dataObj);
                    GdaiModelServingVo gdaiModelServingVo = JSON.parseObject(dataObjStr, GdaiModelServingVo.class);
                    Long servingId = gdaiModelServingVo.getServingId();
                    //更新servingId到订单表bizId字段
                    GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
                    gdaiAlgorithmOrder.setOrderId(orderId);
                    gdaiAlgorithmOrder.setBizId(String.valueOf(servingId));
                    gdaiAlgorithmOrder.setModifyTime(new Date());
                    gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
                }
            } else if ("202".equals(code)) {
                //202表示该地区多云管有部署该算法，直接调扩缩容接口
                Object data = restResult.getData();
                log.info("202表示该地区多云管有部署该算法: [{}]", JSON.toJSONString(data));
                JSONObject json = JSON.parseObject(JSON.toJSONString(data));
                String taskCode = json.getString("taskCode");
                String servingId = json.getString("servingId");
                //servingId赋值给bizId
                bizId = servingId;
                //1.获取业务ID同步至订单表
                if (jsonObject == null) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "业务参数为空", bizId, new Date()));
                }
                if (!jsonObject.containsKey("replicas")) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "replicas不存在", bizId, new Date()));
                }
                String replicas = jsonObject.getString("replicas");
                if (StringUtils.isBlank(replicas)) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "replicas值为空", bizId, new Date()));
                }
                if (!jsonObject.containsKey("taskReqId")) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId不存在", bizId, new Date()));
                }
                String taskReqId = jsonObject.getString("taskReqId");
                if (StringUtils.isBlank(taskReqId)) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskReqId值为空", bizId, new Date()));
                }
                //                    if (!jsonObject.containsKey("taskCode")) {
                //                        //参数异常，订单状态置为失败，调接口回单失败原因
                //                        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskCode不存在", bizId, new Date()));
                //                    }
                //                    String taskCode = jsonObject.getString("taskCode");
                if (StringUtils.isBlank(taskCode)) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "taskCode值为空", bizId, new Date()));
                }
                if (!jsonObject.containsKey("productCode")) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "productCode不存在", bizId, new Date()));
                }
                String productCode = jsonObject.getString("productCode");
                if (StringUtils.isBlank(productCode)) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "productCode值为空", bizId, new Date()));
                }
                if (!jsonObject.containsKey("userId")) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "userId不存在", bizId, new Date()));
                }
                String userId = jsonObject.getString("userId");
                if (StringUtils.isBlank(userId)) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "userId值为空", bizId, new Date()));
                }
                if (!jsonObject.containsKey("tenantId")) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "tenantId不存在", bizId, new Date()));
                }
                String tenantId = jsonObject.getString("tenantId");
                if (StringUtils.isBlank(tenantId)) {
                    //参数异常，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "tenantId值为空", bizId, new Date()));
                }
                //同步业务ID到订单表
                GdaiAlgorithmOrder gdaiAlgorithmOrder = new GdaiAlgorithmOrder();
                gdaiAlgorithmOrder.setOrderId(orderId);
                gdaiAlgorithmOrder.setBizId(bizId);
                gdaiAlgorithmOrder.setModifyTime(new Date());
                gdaiAlgorithmOrderService.updateBizId(gdaiAlgorithmOrder);
                //2.调扩缩容接口
                IcspResultVo icspResultVo = icspService.instNumUpdate(replicas, taskReqId, taskCode, productCode, userId, tenantId);
                if (icspResultVo == null) {
                    //扩缩容失败，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", "多云管扩缩容接口异常", bizId, new Date()));
                }
                String code1 = icspResultVo.getCode();
                String message = icspResultVo.getMessage();
                if (!code1.equals("0")) {
                    //扩缩容失败，订单状态置为失败，调接口回单失败原因
                    gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", message, bizId, new Date()));
                }
            }
        } else {
            //查询失败（扩缩容失败），订单状态置为失败，调接口回单失败原因
            String message = restResult.getMessage();
            gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "4", message, bizId, new Date()));
        }
    } catch (Exception e) {
        log.info("多云管扩缩容异常:", e);
        //调接口回单失败原因
        gdaiAlgorithmOrderService.updateAndReceiptOrder(new GdaiAlgorithmOrderVo(orderId, "5", e.getMessage(), bizId, new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiAlgorithmOrder
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.vo.GdaiAlgorithmOrderVo
com.eshore.gdai.trainingcenter.vo.GdaiModelDeployVo
com.eshore.gdai.trainingcenter.vo.GdaiModelServingAddVo
com.eshore.gdai.trainingcenter.vo.GdaiModelServingVo
com.eshore.gdai.trainingcenter.vo.IcspResultVo
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiAlgorithmOrderService gdaiAlgorithmOrderService;
@Resource
private GdaiModelServingService gdaiModelServingService;
@Resource
private IcspService icspService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAlgorithmOrderTask中有一个名为parseJsonArray的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 解析jsonArray
     *
     * @param jsonArrayStr
     * @return
     */
public static String parseJsonArray(String jsonArrayStr) {
    if (StringUtils.isBlank(jsonArrayStr)) {
        //抛出异常待解析数组为空
        throw new RuntimeException("解析数组为空");
    }
    JSONArray jsonArray = JSON.parseArray(jsonArrayStr);
    StringBuilder urls = new StringBuilder();
    for (int i = 0; i < jsonArray.size(); i++) {
        JSONObject jsonObject = jsonArray.getJSONObject(i);
        String url = jsonObject.getString("url");
        // 添加到StringBuilder中，如果不是第一个URL则添加分号
        if (i > 0) {
            urls.append(";");
        }
        urls.append(url);
    }
    // 将StringBuilder转换为String
    return urls.toString();
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAutoTrainingTask中有一个名为checkJobStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 计算训练任务创建时间距当前的时间，如果超过5分钟状态仍然是"Pending"状态，则修改任务状态为"Unkonwn"，随后释放资源。
     */
public void checkJobStatusTask() {
    log.info("检查自训练任务状态定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            List<String> statusList = new ArrayList<>();
            statusList.add("Pending");
            //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
            List<GdaiAutoTraining> GdaiAutoTrainings = gdaiAutoTrainingMapper.selectList(new EntityWrapper<GdaiAutoTraining>().in("status", statusList));
            if (GdaiAutoTrainings != null && GdaiAutoTrainings.size() > 0) {
                for (GdaiAutoTraining auto : GdaiAutoTrainings) {
                    Long autoTrainId = auto.getAutoTrainId();
                    Long trainSetId = auto.getTrainSetId();
                    String namespace = auto.getNameSpace();
                    String podLabelSelector = auto.getPodLabelSelector();
                    Long projectId = auto.getProjectId();
                    Date createTime = auto.getCreateTime();
                    if (StringUtils.isNotBlank(namespace)) {
                        V1PodList v1PodList = apiInstance.listNamespacedPod(namespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
                        if (v1PodList != null) {
                            List<V1Pod> podList = v1PodList.getItems();
                            if (podList != null && podList.size() > 0) {
                                for (int i = 0; i < podList.size(); i++) {
                                    Date date = new Date();
                                    Long distanceMin = DateUtil.getDistanceMin(createTime, date);
                                    if (distanceMin >= 5) {
                                        buildCntrMsg("unkonwn", auto, k8sClientOperator);
                                        gdaiAutoTrainingMapper.updateById(auto);
                                        gdaiAutoTrainingMapper.updateById(new GdaiAutoTraining(autoTrainId, "Unkonwn", new Date()));
                                        GdaiAutoTrainingSet gdaiAutoTrainingSet = new GdaiAutoTrainingSet();
                                        gdaiAutoTrainingSet.setTrainSetId(trainSetId);
                                        gdaiAutoTrainingSet.setStatus("Unkonwn");
                                        gdaiAutoTrainingSet.setModifyTime(new Date());
                                        gdaiAutoTrainingSetMapper.updateById(gdaiAutoTrainingSet);
                                        V1Pod curV1Pod = podList.get(i);
                                        //查询该容器在那个节点上
                                        String nodeIp = curV1Pod.getSpec().getNodeName();
                                        //                                            //根据项目ID查询项目资源情况
                                        //                                            GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
                                        //                                            if (gdaiProject != null) {
                                        //                                                //释放配额
                                        //                                                gdaiProjectService.releaseProject(projectId, "train", auto.getCore(), auto.getMemorySize(), auto.getGpuSize());
                                        //                                                //释放资源
                                        //                                                gdaiNodeInfoService.releaseNode(nodeIp, "train", auto.getCore(), auto.getMemorySize(), auto.getGpuSize());
                                        //                                            }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("检查自训练任务状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("检查自训练任务状态定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.util.DateUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAutoTrainingTask中有一个名为updateJobStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 定时更新job状态
     */
public void updateJobStatusTask() {
    log.info("更新自训练任务状态定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            List<String> statusList = new ArrayList<>();
            statusList.add("Pending");
            statusList.add("Running");
            //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
            List<GdaiAutoTraining> GdaiAutoTrainings = gdaiAutoTrainingMapper.selectList(new EntityWrapper<GdaiAutoTraining>().in("status", statusList));
            if (GdaiAutoTrainings != null && GdaiAutoTrainings.size() > 0) {
                for (GdaiAutoTraining auto : GdaiAutoTrainings) {
                    Long autoTrainId = auto.getAutoTrainId();
                    Long trainSetId = auto.getTrainSetId();
                    String status = auto.getStatus();
                    String currentJobName = auto.getJobName();
                    String namespace = auto.getNameSpace();
                    String podLabelSelector = auto.getPodLabelSelector();
                    Long projectId = auto.getProjectId();
                    if (StringUtils.isNotBlank(namespace)) {
                        V1PodList v1PodList = apiInstance.listNamespacedPod(namespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
                        if (v1PodList != null) {
                            List<V1Pod> podList = v1PodList.getItems();
                            if (podList != null && podList.size() > 0) {
                                for (int i = 0; i < podList.size(); i++) {
                                    V1Pod curV1Pod = podList.get(i);
                                    //查询该容器在那个节点上
                                    String nodeIp = curV1Pod.getSpec().getNodeName();
                                    String jobName = curV1Pod.getMetadata().getName().substring(0, curV1Pod.getMetadata().getName().lastIndexOf("-"));
                                    if (currentJobName.equals(jobName)) {
                                        //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态 Completed 已完成
                                        String phaseStatus = curV1Pod.getStatus().getPhase();
                                        if (!status.equals(phaseStatus)) {
                                            buildCntrMsg(phaseStatus, auto, k8sClientOperator);
                                            gdaiAutoTrainingMapper.updateById(auto);
                                            gdaiAutoTrainingService.trainingModelFinish(auto);
                                            Date date = new Date();
                                            GdaiAutoTraining autoTraining = new GdaiAutoTraining(autoTrainId, phaseStatus, date);
                                            gdaiAutoTrainingMapper.updateById(autoTraining);
                                            GdaiAutoTrainingSet gdaiAutoTrainingSet = new GdaiAutoTrainingSet();
                                            gdaiAutoTrainingSet.setTrainSetId(trainSetId);
                                            gdaiAutoTrainingSet.setStatus(phaseStatus);
                                            gdaiAutoTrainingSet.setModifyTime(new Date());
                                            gdaiAutoTrainingSetMapper.updateById(gdaiAutoTrainingSet);
                                            //                                                //状态不为Pending和Running表示任务已结束
                                            //                                                if (!"Pending".equals(phaseStatus) && !"Running".equals(phaseStatus)) {
                                            //                                                    //根据项目ID查询项目资源情况
                                            //                                                    GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
                                            //                                                    if (gdaiProject != null) {
                                            //                                                        //释放配额
                                            //                                                        gdaiProjectService.releaseProject(projectId, "train", auto.getCore(), auto.getMemorySize(), auto.getGpuSize());
                                            //                                                        //释放资源
                                            //                                                        gdaiNodeInfoService.releaseNode(nodeIp, "train", auto.getCore(), auto.getMemorySize(), auto.getGpuSize());
                                            //                                                    }
                                            //                                                }
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        log.info("namespace为空,trainId为: [{}]", autoTrainId);
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("更新自训练任务状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("更新自训练任务状态定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiAutoTraining
com.eshore.gdai.trainingcenter.entity.GdaiAutoTrainingSet
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.util.DateUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiAutoTrainingSetMapper gdaiAutoTrainingSetMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
@Resource
private GdaiAutoTrainingService gdaiAutoTrainingService;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiAutoTrainingTask中有一个名为buildCntrMsg的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildCntrMsg(String message, GdaiAutoTraining gdaiAutoTraining, K8sClientOperator k8sClientOperator) throws Exception {
    JSONObject object = new JSONObject();
    if (StringUtils.isNotEmpty(gdaiAutoTraining.getCntrMsg())) {
        object = JSON.parseObject(gdaiAutoTraining.getCntrMsg());
    }
    object.put("message", message);
    if (StringUtils.isEmpty(gdaiAutoTraining.getPodName())) {
        V1PodList curV1PodList = k8sClientOperator.listNamespacedPod(gdaiAutoTraining.getNameSpace(), gdaiAutoTraining.getPodLabelSelector());
        if (curV1PodList != null && !curV1PodList.getItems().isEmpty()) {
            gdaiAutoTraining.setPodName(curV1PodList.getItems().get(0).getMetadata().getName());
        }
    }
    if (StringUtils.isNotEmpty(gdaiAutoTraining.getPodName())) {
        List<Event> events = k8sClientOperator.getEvents(gdaiAutoTraining.getNameSpace(), gdaiAutoTraining.getPodName());
        if (events != null) {
            object.put("event", events);
        }
    }
    if (StringUtils.isNotEmpty(gdaiAutoTraining.getNameSpace())) {
        ContainerState state = k8sClientOperator.getContainerState(gdaiAutoTraining.getNameSpace(), gdaiAutoTraining.getPodLabelSelector());
        if (state != null) {
            object.put("state", state);
        }
    }
    gdaiAutoTraining.setCntrMsg(JSON.toJSONString(object));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiDevModelTask中有一个名为checkDevPodTimeoutTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 定时检查更新部署状态
     */
public void checkDevPodTimeoutTask() {
    log.info("检查模型开发容器是否超时定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            List<GdaiDevModel> gdaiDevModels = gdaiDevModelMapper.selectList(new EntityWrapper<>());
            if (gdaiDevModels != null && gdaiDevModels.size() > 0) {
                List<GdaiDevModel> list = new ArrayList<>();
                ApiClient client = k8sInit2.getConnection();
                Date date = new Date();
                for (GdaiDevModel devModel : gdaiDevModels) {
                    GdaiDevModel dev = new GdaiDevModel();
                    Long devId = devModel.getDevId();
                    String status = devModel.getStatus();
                    String namespaceName = devModel.getNamespaceName();
                    String podLabelSelector = devModel.getPodLabelSelector();
                    if (StringUtils.isNotBlank(namespaceName) && StringUtils.isNotBlank(podLabelSelector)) {
                        ContainerState containerState = k8sClientOperator.getContainerState(namespaceName, podLabelSelector);
                        if (containerState != null) {
                            String state = containerState.getState();
                            String reason = containerState.getReason();
                            String message = containerState.getMessage();
                            String podName = containerState.getPodName();
                            //获取pod创建时间并转换为Date类型
                            OffsetDateTime creationSecond = containerState.getCreationTimestamp();
                            if (creationSecond != null) {
                                Date creationDate = DateUtil.offsetDateTimeToDate(creationSecond);
                                //计算pod创建到现在时间(分钟)
                                Long distanceMin = DateUtil.getDistanceMin(creationDate, new Date());
                                dev.setPodName(podName);
                                dev.setDevId(devId);
                                dev.setModifyTime(date);
                                if ("running".equals(state) && StringUtils.isBlank(reason) && StringUtils.isBlank(message)) {
                                    if (!"S0R".equals(status)) {
                                        dev.setStatus("S0R");
                                        buildCntrMsg(message, devModel, k8sClientOperator);
                                        dev.setCntrMsg(devModel.getCntrMsg());
                                        list.add(dev);
                                    } else {
                                        if (distanceMin >= stopTime) {
                                            devModel.setModifyTime(date);
                                            //如果模型开发容器运行时间超过5小时，则自动停止容器
                                            stopNotebook(devModel, client, message);
                                        }
                                    }
                                } else {
                                    if (distanceMin <= 5) {
                                        if (!"S0C".equals(status)) {
                                            dev.setStatus("S0C");
                                            buildCntrMsg(message, devModel, k8sClientOperator);
                                            dev.setCntrMsg(devModel.getCntrMsg());
                                            list.add(dev);
                                        }
                                    } else {
                                        if (!"S0E".equals(status)) {
                                            dev.setStatus("S0E");
                                            buildCntrMsg(message, devModel, k8sClientOperator);
                                            dev.setCntrMsg(devModel.getCntrMsg());
                                            list.add(dev);
                                            //资源占用与释放考虑下？
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        dev.setPodName("");
                        dev.setDevId(devId);
                        dev.setModifyTime(date);
                        dev.setStatus("S0E");
                        dev.setCntrMsg("");
                        list.add(dev);
                    }
                }
                //批量修改
                if (list != null && list.size() > 0) {
                    gdaiDevModelMapper.updateBatch(list);
                }
            }
        }
    } catch (Exception e) {
        log.info("更新模型开发状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("检查模型开发容器是否超时定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
io.kubernetes.client.openapi.ApiClient
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.time.OffsetDateTime
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private K8sInit2 k8sInit2;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;
/**
 * 模型开发容器停止时间
 */
@Value("${devModelPod.stopTime}")
private Long stopTime;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiDevModelTask中有一个名为stopNotebook的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void stopNotebook(GdaiDevModel gdaiDevModel, ApiClient client, String message) {
    log.info("GdaiDevModelTask.stopNotebook params: [{}]", JSON.toJSONString(gdaiDevModel));
    Long devId = gdaiDevModel.getDevId();
    Long projectId = gdaiDevModel.getProjectId();
    String podName = gdaiDevModel.getPodName();
    AppsV1Api appsInstance = new AppsV1Api(client);
    CoreV1Api apiInstance = new CoreV1Api(client);
    // 停止容器， 把其副本修改为0， 更新副本的json串
    String jsonPatchStr = "[{\"op\":\"replace\",\"path\":\"/spec/replicas\", \"value\": " + "0" + " }]";
    V1Patch body = new V1Patch(jsonPatchStr);
    try {
        //删除之前查询该pod节点
        V1PodList v1PodList = apiInstance.listNamespacedPod(gdaiDevModel.getNamespaceName(), null, null, null, null, gdaiDevModel.getPodLabelSelector(), null, null, null, null, null);
        String nodeIp = "";
        if (v1PodList != null && v1PodList.getItems().size() > 0) {
            List<V1Pod> items = v1PodList.getItems();
            nodeIp = items.get(0).getSpec().getNodeName();
        }
        appsInstance.patchNamespacedDeployment(gdaiDevModel.getDeploymentName(), gdaiDevModel.getNamespaceName(), body, null, null, null, null);
        //sleep是给容器停止预留一定时间
        // Thread.sleep(20 * 1000);
        buildCntrMsg(message, gdaiDevModel, k8sClientOperator);
        String cntrMsg = gdaiDevModel.getCntrMsg();
        gdaiDevModelMapper.updateById(new GdaiDevModel(devId, podName, "S0T", cntrMsg, new Date()));
        //            //根据项目ID查询该项目当前资源占用情况
        //            GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
        //            if (gdaiProject != null) {
        //                //释放配额
        //                gdaiProjectService.releaseProject(projectId, "dev", gdaiDevModel.getCore(), gdaiDevModel.getMemorySize(), gdaiDevModel.getGpuSize());
        //                //释放资源
        //                gdaiNodeInfoService.releaseNode(nodeIp, "dev", gdaiDevModel.getCore(), gdaiDevModel.getMemorySize(), gdaiDevModel.getGpuSize());
        //                log.info("停止成功");
        //            } else {
        //                log.info("该项目不存在");
        //            }
    } catch (Exception e) {
        log.info("停止异常", e);
        //gdaiDevModelMapper.updateById(new GdaiDevModel(devId, "S0R", new Date()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
com.eshore.gdai.trainingcenter.entity.GdaiProject
io.kubernetes.client.custom.V1Patch
io.kubernetes.client.openapi.apis.AppsV1Api
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiDevModelTask中有一个名为buildCntrMsg的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildCntrMsg(String message, GdaiDevModel gdaiDevModel, K8sClientOperator k8sClientOperator) throws Exception {
    JSONObject object = new JSONObject();
    if (StringUtils.isNotEmpty(gdaiDevModel.getCntrMsg())) {
        object = JSON.parseObject(gdaiDevModel.getCntrMsg());
    }
    object.put("message", message);
    if (StringUtils.isEmpty(gdaiDevModel.getPodName())) {
        V1PodList curV1PodList = k8sClientOperator.listNamespacedPod(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector());
        if (curV1PodList != null && !curV1PodList.getItems().isEmpty()) {
            gdaiDevModel.setPodName(curV1PodList.getItems().get(0).getMetadata().getName());
        }
    }
    if (StringUtils.isNotEmpty(gdaiDevModel.getPodName())) {
        List<Event> events = k8sClientOperator.getEvents(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodName());
        if (events != null) {
            object.put("event", events);
        }
    }
    if (StringUtils.isNotEmpty(gdaiDevModel.getDeploymentName())) {
        ContainerState state = k8sClientOperator.getContainerState(gdaiDevModel.getNamespaceName(), gdaiDevModel.getPodLabelSelector());
        if (state != null) {
            object.put("state", state);
        }
    }
    gdaiDevModel.setCntrMsg(JSON.toJSONString(object));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiIntelligentAnnotationTask中有一个名为checkAnnotationJobStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 计算训练任务创建时间距当前的时间，如果超过5分钟状态仍然是"Pending"状态，则修改任务状态为"Unkonwn"
     */
public void checkAnnotationJobStatusTask() {
    log.info("检查智能标注job状态定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
            List<GdaiTrainingModel> GdaiTrainingModels = gdaiTrainingModelMapper.selectList(new EntityWrapper<GdaiTrainingModel>().eq("status", "Pending").eq("train_source", "2"));
            if (GdaiTrainingModels != null && GdaiTrainingModels.size() > 0) {
                for (GdaiTrainingModel model : GdaiTrainingModels) {
                    Long trainId = model.getTrainId();
                    String metadataNamespace = model.getNameSpace();
                    String podLabelSelector = model.getPodLabelSelector();
                    Date createTime = model.getCreateTime();
                    if (StringUtils.isNotBlank(metadataNamespace)) {
                        V1PodList v1PodList = apiInstance.listNamespacedPod(metadataNamespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
                        if (v1PodList != null) {
                            List<V1Pod> podList = v1PodList.getItems();
                            if (podList != null && podList.size() > 0) {
                                for (int i = 0; i < podList.size(); i++) {
                                    Date date = new Date();
                                    Long distanceMin = DateUtil.getDistanceMin(createTime, date);
                                    if (distanceMin >= 5) {
                                        gdaiTrainingModelMapper.updateById(new GdaiTrainingModel(trainId, "Unkonwn", new Date()));
                                        List<GdaiIntelligentAnnotationTraining> list = gdaiIntelligentAnnotationTrainingMapper.selectList(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("train_id", trainId));
                                        if (list != null && list.size() > 0) {
                                            GdaiIntelligentAnnotationTraining gdaiIntelligentAnnotationTraining = list.get(0);
                                            Long intelligentAnnotationId = gdaiIntelligentAnnotationTraining.getIntelligentAnnotationId();
                                            gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "S0F", "1", new Date()));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("检查智能标注job状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("检查智能标注job状态定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.util.DateUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiIntelligentAnnotationTask中有一个名为updateAnnotationJobStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 更新智能标注job状态
     */
public void updateAnnotationJobStatusTask() {
    log.info("更新智能标注job状态定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
            List<GdaiTrainingModel> GdaiTrainingModels = gdaiTrainingModelMapper.selectList(new EntityWrapper<GdaiTrainingModel>().eq("train_source", "2"));
            if (GdaiTrainingModels != null && GdaiTrainingModels.size() > 0) {
                for (GdaiTrainingModel model : GdaiTrainingModels) {
                    Long trainId = model.getTrainId();
                    String status = model.getStatus();
                    String currentJobName = model.getJobName();
                    String metadataNamespace = model.getNameSpace();
                    String podLabelSelector = model.getPodLabelSelector();
                    if (StringUtils.isNotBlank(metadataNamespace)) {
                        V1PodList v1PodList = apiInstance.listNamespacedPod(metadataNamespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
                        if (v1PodList != null) {
                            List<V1Pod> podList = v1PodList.getItems();
                            if (podList != null && podList.size() > 0) {
                                for (int i = 0; i < podList.size(); i++) {
                                    V1Pod curV1Pod = podList.get(i);
                                    String jobName = curV1Pod.getMetadata().getName().substring(0, curV1Pod.getMetadata().getName().lastIndexOf("-"));
                                    if (currentJobName.equals(jobName)) {
                                        //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态 Completed 已完成
                                        String phaseStatus = curV1Pod.getStatus().getPhase();
                                        if (!status.equals(phaseStatus)) {
                                            List<GdaiIntelligentAnnotationTraining> list = gdaiIntelligentAnnotationTrainingMapper.selectList(new EntityWrapper<GdaiIntelligentAnnotationTraining>().eq("train_id", trainId));
                                            GdaiIntelligentAnnotation gdaiIntelligentAnnotation = null;
                                            Long intelligentAnnotationId = null;
                                            if (list != null && list.size() > 0) {
                                                GdaiIntelligentAnnotationTraining gdaiIntelligentAnnotationTraining = list.get(0);
                                                Long annotationTrainingId = gdaiIntelligentAnnotationTraining.getIntelligentAnnotationId();
                                                gdaiIntelligentAnnotation = gdaiIntelligentAnnotationMapper.selectById(annotationTrainingId);
                                                if (gdaiIntelligentAnnotation != null) {
                                                    intelligentAnnotationId = gdaiIntelligentAnnotation.getIntelligentAnnotationId();
                                                } else {
                                                    throw new RuntimeException("gdaiIntelligentAnnotation is null");
                                                }
                                            }
                                            if ("Succeeded".equals(phaseStatus)) {
                                                //状态为Succeeded表示任务已训练完成,调接口将csv数据入库到临时表
                                                if (gdaiIntelligentAnnotation != null) {
                                                    Long datasetId = gdaiIntelligentAnnotation.getDatasetId();
                                                    String csvFilePath = "/datasets/csv/nanli.csv";
                                                    String confirmStatus = "0";
                                                    RestResult restResult = gdaiDatafileLabelService.addBatchFromCsvFile(datasetId, confirmStatus, csvFilePath, 0f);
                                                    if (restResult != null) {
                                                        String code = restResult.getCode();
                                                        if ("200".equals(code)) {
                                                            log.info("csv文件入库成功");
                                                            Object data = restResult.getData();
                                                            JSONObject json = (JSONObject) JSONObject.toJSON(data);
                                                            int resultCount = (int) json.get("resultCount");
                                                            if (resultCount == 0) {
                                                                //更新智能标注hard_filter_status状态为：3-效果确认
                                                                gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "3", new Date()));
                                                            } else {
                                                                //更新智能标注hard_filter_status状态为：2-难例确认
                                                                gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "2", new Date()));
                                                            }
                                                        } else {
                                                            log.info("csv文件入库失败", restResult.getMessage());
                                                            GdaiIntelligentAnnotation intelligentAnnotation = new GdaiIntelligentAnnotation();
                                                            intelligentAnnotation.setIntelligentAnnotationId(intelligentAnnotationId);
                                                            intelligentAnnotation.setStatus("S0F");
                                                            intelligentAnnotation.setModifyTime(new Date());
                                                            gdaiIntelligentAnnotationMapper.updateById(intelligentAnnotation);
                                                        }
                                                    }
                                                }
                                            } else if (!"Pending".equals(phaseStatus) && !"Running".equals(phaseStatus) && !"Succeeded".equals(phaseStatus)) {
                                                gdaiIntelligentAnnotationMapper.updateById(new GdaiIntelligentAnnotation(intelligentAnnotationId, "S0F", "1", new Date()));
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        log.info("metadataNamespace为空,trainId为: [{}]", trainId);
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("更新智能标注job状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("更新智能标注job状态定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotation
com.eshore.gdai.trainingcenter.entity.GdaiIntelligentAnnotationTraining
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.util.DateUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiIntelligentAnnotationMapper gdaiIntelligentAnnotationMapper;
@Resource
private GdaiIntelligentAnnotationTrainingMapper gdaiIntelligentAnnotationTrainingMapper;
@Resource
private GdaiDatafileLabelService gdaiDatafileLabelService;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiK8sResourceTask中有一个名为checkPodTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void checkPodTask() {
    try {
        String labelSelector = LabelUtils.getLabelsStr(LabelUtils.getBizEnvLabel());
        List<PodBo> podBoList = podService.listAll("", labelSelector);
        for (PodBo podBo : podBoList) {
            podCallback.callback("update", podBo);
        }
    } catch (Exception e) {
        log.error(e.getMessage());
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.PodBo
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
java.util.List
### 类级别的变量
@Resource
private PodService podService;
@Resource
private PodCallback podCallback;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiK8sResourceTask中有一个名为checkDeploymentTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void checkDeploymentTask() {
    try {
        String labelSelector = LabelUtils.getLabelsStr(LabelUtils.getBizEnvLabel());
        List<DeploymentBo> deploymentBoList = deploymentService.listAll("", labelSelector);
        for (DeploymentBo deploymentBo : deploymentBoList) {
            deploymentCallback.callback("update", deploymentBo);
        }
    } catch (Exception e) {
        log.error(e.getMessage());
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.DeploymentBo
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
java.util.List
### 类级别的变量
@Resource
private DeploymentService deploymentService;
@Resource
private DeploymentCallback deploymentCallback;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiK8sResourceTask中有一个名为checkJobTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void checkJobTask() {
    try {
        String labelSelector = LabelUtils.getLabelsStr(LabelUtils.getBizEnvLabel());
        List<JobBo> jobBoList = jobService.listAll("", labelSelector);
        for (JobBo jobBo : jobBoList) {
            jobCallback.callback("update", jobBo);
        }
    } catch (Exception e) {
        log.error(e.getMessage());
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.domain.bo.JobBo
com.eshore.gdai.trainingcenter.k8s.util.LabelUtils
java.util.List
### 类级别的变量
@Resource
private JobCallback jobCallback;
@Resource
private JobService jobService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiK8sResourceTask中有一个名为deletePodTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void deletePodTask() {
    try {
        //清理已删除的pod资源
        gdaiPodService.deletePod();
    } catch (Exception e) {
        log.error(e.getMessage());
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.k8s.service.PodService
### 类级别的变量
@Resource
private GdaiPodService gdaiPodService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiMarkJobTask中有一个名为checkMarkJobStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 检查多人标注任务是否到期
     */
public void checkMarkJobStatusTask() {
    log.info("检查多人标注任务是否到期定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            //扫描多人标注主任务表，根据设定时间，检查任务是否过期
            List<GdaiMarkJob> markJobList = gdaiMarkJobMapper.selectList(new EntityWrapper<GdaiMarkJob>().in("status", "1,2,3"));
            if (markJobList != null && markJobList.size() > 0) {
                for (GdaiMarkJob gdaiMarkJob : markJobList) {
                    Long jobId = gdaiMarkJob.getJobId();
                    Date jobEndTime = gdaiMarkJob.getJobEndTime();
                    //将现在时间与获取的时间进行比较，看是否超时
                    Long distanceTimestamp = DateUtil.getDiffTime(new Date(), jobEndTime);
                    if (distanceTimestamp > 0) {
                        //说明超过设定时间，定时任务自动修改主任务为4-标注完成（所有子任务状态都为已提交）,子任务改为3-已提交
                        Date date = new Date();
                        gdaiMarkJobMapper.updateById(new GdaiMarkJob(jobId, "4", date));
                        gdaiMarkSubJobMapper.updateByJobId(new GdaiMarkSubJob(jobId, "3", date));
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("更新多人标注任务状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("检查多人标注任务是否到期定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiMarkJob
com.eshore.gdai.trainingcenter.entity.GdaiMarkSubJob
com.eshore.gdai.trainingcenter.util.DateUtil
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiMarkJobMapper gdaiMarkJobMapper;
@Resource
private GdaiMarkSubJobMapper gdaiMarkSubJobMapper;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiModelDeployTask中有一个名为checkDeployStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    @Transactional(rollbackFor = Exception.class)
public void checkDeployStatusTask() {
    log.info("检查部署状态定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            List<GdaiModelDeploy> gdaiModelDeploys = gdaiModelDeployMapper.selectList(new EntityWrapper<GdaiModelDeploy>().eq("deleted", false));
            if (gdaiModelDeploys != null && gdaiModelDeploys.size() > 0) {
                List<GdaiModelDeploy> list = new ArrayList<>();
                Date date = new Date();
                for (GdaiModelDeploy deploy : gdaiModelDeploys) {
                    GdaiModelDeploy modelDeploy = new GdaiModelDeploy();
                    Long deployId = deploy.getDeployId();
                    String status = deploy.getStatus();
                    String pubNamespaceName = deploy.getPubNamespaceName();
                    String pubPodLabelSelector = deploy.getPubPodLabelSelector();
                    if (StringUtils.isNotBlank(pubNamespaceName) && StringUtils.isNotBlank(pubPodLabelSelector)) {
                        ContainerState containerState = k8sClientOperator.getContainerState(pubNamespaceName, pubPodLabelSelector);
                        if (containerState != null) {
                            //更新pod新名字
                            String state = containerState.getState();
                            String reason = containerState.getReason();
                            String message = containerState.getMessage();
                            String podName = containerState.getPodName();
                            //获取pod创建时间并转换为Date类型
                            OffsetDateTime creationSecond = containerState.getCreationTimestamp();
                            if (creationSecond != null) {
                                Date creationDate = DateUtil.offsetDateTimeToDate(creationSecond);
                                //计算pod创建到现在时间(分钟)
                                Long distanceMin = DateUtil.getDistanceMin(creationDate, new Date());
                                modelDeploy.setPubPodName(podName);
                                modelDeploy.setDeployId(deployId);
                                modelDeploy.setModifyTime(date);
                                if ("running".equals(state) && StringUtils.isBlank(reason) && StringUtils.isBlank(message)) {
                                    if (!"S2R".equals(status)) {
                                        modelDeploy.setStatus("S2R");
                                        buildCntrMsg(message, deploy, k8sClientOperator);
                                        modelDeploy.setPubCntrMsg(deploy.getPubCntrMsg());
                                        list.add(modelDeploy);
                                    }
                                } else {
                                    if (distanceMin <= 5) {
                                        if (!"S2C".equals(status)) {
                                            modelDeploy.setStatus("S2C");
                                            buildCntrMsg(message, deploy, k8sClientOperator);
                                            modelDeploy.setPubCntrMsg(deploy.getPubCntrMsg());
                                            list.add(modelDeploy);
                                        }
                                    } else {
                                        if (!"S2E".equals(status)) {
                                            modelDeploy.setStatus("S2E");
                                            buildCntrMsg(message, deploy, k8sClientOperator);
                                            modelDeploy.setPubCntrMsg(deploy.getPubCntrMsg());
                                            list.add(modelDeploy);
                                            //资源占用与释放考虑下？
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        modelDeploy.setPubPodName("");
                        modelDeploy.setDeployId(deployId);
                        modelDeploy.setModifyTime(date);
                        modelDeploy.setStatus("S2E");
                        modelDeploy.setPubCntrMsg("");
                        list.add(modelDeploy);
                    }
                }
                //批量修改
                if (list != null && list.size() > 0) {
                    gdaiModelDeployMapper.updateBatch(list);
                }
            }
        }
    } catch (Exception e) {
        log.info("更新部署状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("检查部署状态定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.time.OffsetDateTime
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiModelDeployTask中有一个名为queryActiveTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 定时调用服务激活接口并更新数据库
     */
public void queryActiveTask() {
    log.info("定时调用服务激活接口并更新数据库,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            List<GdaiModelServing> servingList = gdaiModelServingMapper.selectList(new EntityWrapper<GdaiModelServing>().eq("deploy_source", "2"));
            if (servingList != null && servingList.size() > 0) {
                for (GdaiModelServing modelServing : servingList) {
                    //获取服务ID
                    Long servingId = modelServing.getServingId();
                    GdaiModelDeploy deploy = gdaiModelDeployMapper.selectOne(new GdaiModelDeploy(servingId));
                    if (deploy != null) {
                        //获取context大字段中的active字段，如果为1则需要调用激活接口
                        String context = deploy.getContext();
                        JSONObject jsonContext = JSON.parseObject(context);
                        String active = jsonContext.getString("active");
                        if ("1".equals(active)) {
                            String status = deploy.getStatus();
                            if (StringUtils.isNotBlank(status) && ("S2R").equalsIgnoreCase(status)) {
                                //处理服务激活
                                log.info("服务ID为：" + servingId + "的服务状态为：" + status + "，准备激活服务");
                                deploy.setDeploySource(String.valueOf(modelServing.getDeploySource()));
                                gdaiModelDeployService.activeHandle(deploy);
                            }
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("调用服务激活接口异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("定时调用服务激活接口并更新数据库,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.util.DateUtil
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiModelDeployTask中有一个名为buildCntrMsg的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildCntrMsg(String message, GdaiModelDeploy gdaiModelDeploy, K8sClientOperator k8sClientOperator) throws Exception {
    JSONObject object = new JSONObject();
    if (StringUtils.isNotEmpty(gdaiModelDeploy.getPubCntrMsg())) {
        object = JSON.parseObject(gdaiModelDeploy.getPubCntrMsg());
    }
    object.put("message", message);
    if (StringUtils.isEmpty(gdaiModelDeploy.getPubPodName())) {
        V1PodList curV1PodList = k8sClientOperator.listNamespacedPod(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector());
        if (curV1PodList != null && !curV1PodList.getItems().isEmpty()) {
            gdaiModelDeploy.setPubPodName(curV1PodList.getItems().get(0).getMetadata().getName());
        }
    }
    if (StringUtils.isNotEmpty(gdaiModelDeploy.getPubPodName())) {
        List<Event> events = k8sClientOperator.getEvents(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodName());
        if (events != null) {
            object.put("event", events);
        }
    }
    if (StringUtils.isNotEmpty(gdaiModelDeploy.getPubDeploymentName())) {
        ContainerState state = k8sClientOperator.getContainerState(gdaiModelDeploy.getPubNamespaceName(), gdaiModelDeploy.getPubPodLabelSelector());
        if (state != null) {
            object.put("state", state);
        }
    }
    gdaiModelDeploy.setPubCntrMsg(JSON.toJSONString(object));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiModelServingTask中有一个名为checkServingProcessing的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 定时查询处理中订单(10秒一次)
     */
public void checkServingProcessing() {
    log.info("定时扫描多云管部署记录,开始时间:[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    Long deployId = null;
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            //查询gdai_model_serving表中serving_type状态为:2-边缘云资源池的订单
            List<GdaiModelServing> gdaiModelServingList = gdaiModelServingMapper.selectList(new EntityWrapper<GdaiModelServing>().eq("serving_type", "2"));
            if (gdaiModelServingList != null && gdaiModelServingList.size() > 0) {
                for (GdaiModelServing modelServing : gdaiModelServingList) {
                    Long servingId = modelServing.getServingId();
                    GdaiModelDeploy deploy = gdaiModelDeployMapper.selectCurrentDeploy(servingId);
                    if (deploy != null) {
                        String status = deploy.getStatus();
                        if (!status.equals("S2E")) {
                            //获取部署ID
                            deployId = deploy.getDeployId();
                            //调查询接口的taskReqId，没有业务含义，以90开头
                            String taskReqId = "90" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
                            //获取任务新增部署时的taskReqId（taskCode）
                            //获取模型部署时间，便于将来用来做超时判断
                            Date createTime = deploy.getCreateTime();
                            String context = deploy.getContext();
                            JSONObject jsonContext = JSON.parseObject(context);
                            JSONObject icsp = jsonContext.getJSONObject("icsp");
                            String taskCode = icsp.getString("taskReqId");
                            //调多云管查询接口
                            IcspResultVo taskQueryResultVo = icspService.taskQuery(taskReqId, taskCode);
                            log.info("多云管查询接口返回值:[{}]", JSON.toJSONString(taskQueryResultVo));
                            if (taskQueryResultVo == null) {
                                //调任务调度结果信息查询失败，更新部署状态为:S2E-部署异常
                                GdaiModelDeploy deploy1 = new GdaiModelDeploy();
                                deploy1.setDeployId(deployId);
                                deploy1.setStatus("S2E");
                                deploy1.setPubCntrMsg("多云管任务调度结果信息查询接口异常");
                                deploy1.setModifyTime(new Date());
                                //更新并调接口推送部署信息
                                pushDeployInfo(deploy1, deployId);
                            }
                            String code = taskQueryResultVo.getCode();
                            String message = taskQueryResultVo.getMessage();
                            if (code.equals("0")) {
                                //查询成功，更新部署状态为：S2R-运行中，并获取相关信息落库到表中
                                Object data = taskQueryResultVo.getData();
                                JSONObject jsonObject = JSON.parseObject(data.toString());
                                //获取deploymentName
                                String deploymentName = jsonObject.getString("deploymentName");
                                // 从dataObject中获取podInfos字段，这是一个JSONArray
                                JSONArray podInfos = jsonObject.getJSONArray("podInfos");
                                // 获取podInfos的数量
                                int totalPodInfos = podInfos.size();
                                // 计算podState值为2的对象个数(2-运行中)
                                int podState2Count = 0;
                                for (int i = 0; i < podInfos.size(); i++) {
                                    JSONObject podInfo = podInfos.getJSONObject(i);
                                    int podState = podInfo.getInteger("podState");
                                    if (podState == 2) {
                                        podState2Count++;
                                    }
                                }
                                if (totalPodInfos == podState2Count) {
                                    //更新部署状态为：S2R-运行中
                                    //获取url
                                    String url = jsonObject.getString("url");
                                    JSONArray services = JSONArray.parseArray(deploy.getServiceUrl());
                                    if (services != null && services.size() > 0) {
                                        for (int i = 0; i < services.size(); i++) {
                                            JSONObject serviceObj = services.getJSONObject(i);
                                            url = "http://" + url + serviceObj.getString("path");
                                            serviceObj.put("url", url);
                                        }
                                    }
                                    GdaiModelDeploy deploy1 = new GdaiModelDeploy();
                                    deploy1.setDeployId(deploy.getDeployId());
                                    deploy1.setPubDeploymentName(deploymentName);
                                    deploy1.setPubServiceName(deploymentName);
                                    deploy1.setPubPodLabelSelector("app=" + deploymentName);
                                    deploy1.setReplicas(totalPodInfos);
                                    deploy1.setReadyReplicas(podState2Count);
                                    deploy1.setServiceUrl(services.toJSONString());
                                    deploy1.setStatus("S2R");
                                    deploy1.setPubCntrMsg("多云管服务部署成功");
                                    deploy1.setModifyTime(new Date());
                                    //更新并调接口推送部署信息
                                    pushDeployInfo(deploy1, deployId);
                                } else {
                                    //如果不相等，说明还有POD未拉起，此时判断readyReplicas个数，如果至少有一个表示至少拉起一个
                                    if (podState2Count >= 1) {
                                        GdaiModelDeploy deploy1 = new GdaiModelDeploy();
                                        deploy1.setDeployId(deploy.getDeployId());
                                        deploy1.setPubDeploymentName(deploymentName);
                                        deploy1.setPubServiceName(deploymentName);
                                        deploy1.setPubPodLabelSelector("app=" + deploymentName);
                                        deploy1.setReplicas(totalPodInfos);
                                        deploy1.setReadyReplicas(podState2Count);
                                        deploy1.setStatus("S2R");
                                        deploy1.setPubCntrMsg("多云管服务部署中");
                                        deploy1.setModifyTime(new Date());
                                        //更新并调接口推送部署信息
                                        pushDeployInfo(deploy1, deployId);
                                    } else {
                                        GdaiModelDeploy deploy1 = new GdaiModelDeploy();
                                        deploy1.setDeployId(deploy.getDeployId());
                                        deploy1.setPubDeploymentName(deploymentName);
                                        deploy1.setPubServiceName(deploymentName);
                                        deploy1.setPubPodLabelSelector("app=" + deploymentName);
                                        deploy1.setReplicas(totalPodInfos);
                                        deploy1.setReadyReplicas(podState2Count);
                                        deploy1.setStatus("S2C");
                                        deploy1.setPubCntrMsg("多云管服务部署中");
                                        deploy1.setModifyTime(new Date());
                                        //更新并调接口推送部署信息
                                        pushDeployInfo(deploy1, deployId);
                                    }
                                }
                            } else if (code.equals("-1")) {
                                log.info("正在部署中，请10分钟后查询部署结果");
                                //判断部署是否超时
                                Long distanceMin = DateUtil.getDistanceMin(createTime, new Date());
                                GdaiModelDeploy deploy1 = new GdaiModelDeploy();
                                if (distanceMin >= 20) {
                                    //部署超时，部署状态置为失败:S2E-部署失败
                                    deploy1.setDeployId(deploy.getDeployId());
                                    deploy1.setStatus("S2E");
                                    deploy1.setPubCntrMsg(message);
                                    deploy1.setModifyTime(new Date());
                                } else {
                                    //未超时情况下，更新部署状态为：S2C-部署中
                                    deploy1.setDeployId(deploy.getDeployId());
                                    deploy1.setReplicas(0);
                                    deploy1.setReadyReplicas(0);
                                    deploy1.setStatus("S2C");
                                    deploy1.setPubCntrMsg("正在部署中，请10分钟后查询部署结果");
                                    deploy1.setModifyTime(new Date());
                                }
                                //更新并调接口推送部署信息
                                pushDeployInfo(deploy1, deployId);
                            } else {
                                //调任务调度结果信息查询失败，更新部署状态为:S2E-部署异常
                                GdaiModelDeploy deploy1 = new GdaiModelDeploy();
                                deploy1.setDeployId(deploy.getDeployId());
                                deploy1.setStatus("S2E");
                                deploy1.setPubCntrMsg(message);
                                deploy1.setModifyTime(new Date());
                                //更新并调接口推送部署信息
                                pushDeployInfo(deploy1, deployId);
                            }
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("查询部署结果异常：", e);
        //调任务调度结果信息查询异常，订单状态置为异常，调接口回单失败原因
        GdaiModelDeploy deploy1 = new GdaiModelDeploy();
        deploy1.setDeployId(deployId);
        deploy1.setStatus("S2E");
        deploy1.setPubCntrMsg(e.getMessage());
        deploy1.setModifyTime(new Date());
        //更新并调接口推送部署信息
        pushDeployInfo(deploy1, deployId);
    }
    log.info("定时扫描多云管部署记录,结束时间:[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiModelDeploy
com.eshore.gdai.trainingcenter.entity.GdaiModelServing
com.eshore.gdai.trainingcenter.util.DateUtil
com.eshore.gdai.trainingcenter.vo.IcspResultVo
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelServingMapper gdaiModelServingMapper;
@Resource
private IcspService icspService;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiStatisticsTask中有一个名为saveStatisticsTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void saveStatisticsTask() throws Exception {
    //查所有project
    List<GdaiProject> projects = projectService.selectList(new EntityWrapper<>());
    List<GdaiStatisticsVo> gdaiStatisticsVo = new ArrayList<>();
    for (GdaiProject project : projects) {
        //从redis查出对应的指标
        RestResult<JSONObject> result = statisticsService.getStatistics(project.getProjectId());
        if (result.getSuccess() == 0 && result.getData() != null && !result.getData().isEmpty()) {
            JSONObject statisic = result.getData();
            for (String key : statisic.keySet()) {
                GdaiStatisticsVo vo = new GdaiStatisticsVo();
                vo.setProjectId(project.getProjectId());
                vo.setMetricsType(key);
                vo.setMetricsValue(statisic.getString(key));
                gdaiStatisticsVo.add(vo);
            }
        }
    }
    //frameworkUser
    RestResult<JSONObject> result = statisticsService.getFrameworkUser();
    if (result.getSuccess() == 0 && result.getData() != null && !result.getData().isEmpty()) {
        GdaiStatisticsVo vo = new GdaiStatisticsVo();
        //            vo.setProjectId(project.getProjectId());
        vo.setMetricsType("frameworkUser");
        vo.setMetricsValue(result.getData().getString("frameworkUser"));
        gdaiStatisticsVo.add(vo);
    }
    //保存指标
    if (!gdaiStatisticsVo.isEmpty()) {
        gdaiStatisticsMapper.deleteStatistic();
        statisticsService.addBatch(gdaiStatisticsVo);
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.baomidou.mybatisplus.mapper.EntityWrapper
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.vo.GdaiStatisticsVo
java.util.ArrayList
java.util.List
### 类级别的变量
@Resource
private GdaiStatisticsService statisticsService;
@Resource
private GdaiStatisticsMapper gdaiStatisticsMapper;
@Resource
private GdaiProjectService projectService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiTrainingModelTask中有一个名为checkJobStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 计算训练任务创建时间距当前的时间，如果超过5分钟状态仍然是"Pending"状态，则修改任务状态为"Unkonwn"，随后释放资源。
     */
public void checkJobStatusTask() {
    log.info("检查job状态定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            List<String> statusList = new ArrayList<>();
            statusList.add("Pending");
            //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
            List<GdaiTrainingModel> GdaiTrainingModels = gdaiTrainingModelMapper.selectList(new EntityWrapper<GdaiTrainingModel>().in("status", statusList));
            if (GdaiTrainingModels != null && GdaiTrainingModels.size() > 0) {
                for (GdaiTrainingModel model : GdaiTrainingModels) {
                    Long trainId = model.getTrainId();
                    String metadataNamespace = model.getNameSpace();
                    String podLabelSelector = model.getPodLabelSelector();
                    Long projectId = model.getProjectId();
                    String core = model.getCore();
                    String memorySize = model.getMemorySize();
                    String gpuSize = model.getGpuSize();
                    Date createTime = model.getCreateTime();
                    if (StringUtils.isNotBlank(metadataNamespace)) {
                        V1PodList v1PodList = apiInstance.listNamespacedPod(metadataNamespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
                        if (v1PodList != null) {
                            List<V1Pod> podList = v1PodList.getItems();
                            if (podList != null && podList.size() > 0) {
                                for (int i = 0; i < podList.size(); i++) {
                                    Date date = new Date();
                                    Long distanceMin = DateUtil.getDistanceMin(createTime, date);
                                    if (distanceMin >= 5) {
                                        buildCntrMsg("unkonwn", model, k8sClientOperator);
                                        gdaiTrainingModelMapper.updateById(model);
                                        gdaiTrainingModelMapper.updateById(new GdaiTrainingModel(trainId, "Unkonwn", new Date()));
                                        V1Pod curV1Pod = podList.get(i);
                                        //查询该容器在那个节点上
                                        String nodeIp = curV1Pod.getSpec().getNodeName();
                                        //                                            //根据项目ID查询项目资源情况
                                        //                                            GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
                                        //                                            if (gdaiProject != null) {
                                        //                                                //释放配额
                                        //                                                gdaiProjectService.releaseProject(projectId, "train", model.getCore(), model.getMemorySize(), model.getGpuSize());
                                        //                                                //释放资源
                                        //                                                gdaiNodeInfoService.releaseNode(nodeIp, "train", model.getCore(), model.getMemorySize(), model.getGpuSize());
                                        //                                            }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("检查job状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("检查job状态定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.util.DateUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiTrainingModelTask中有一个名为updateJobStatusTask的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 定时更新job状态
     */
public void updateJobStatusTask() {
    log.info("更新job状态定时任务开始执行,开始时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
    try {
        if (checkLocalHostIpMatchIp(localhostip)) {
            ApiClient client = k8sInit2.getConnection();
            CoreV1Api apiInstance = new CoreV1Api(client);
            List<String> statusList = new ArrayList<>();
            statusList.add("Pending");
            statusList.add("Running");
            //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态
            List<GdaiTrainingModel> GdaiTrainingModels = gdaiTrainingModelMapper.selectList(new EntityWrapper<GdaiTrainingModel>().in("status", statusList));
            if (GdaiTrainingModels != null && GdaiTrainingModels.size() > 0) {
                for (GdaiTrainingModel model : GdaiTrainingModels) {
                    Long trainId = model.getTrainId();
                    String status = model.getStatus();
                    String currentJobName = model.getJobName();
                    String metadataNamespace = model.getNameSpace();
                    String podLabelSelector = model.getPodLabelSelector();
                    Long projectId = model.getProjectId();
                    if (StringUtils.isNotBlank(metadataNamespace)) {
                        V1PodList v1PodList = apiInstance.listNamespacedPod(metadataNamespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
                        if (v1PodList != null) {
                            List<V1Pod> podList = v1PodList.getItems();
                            if (podList != null && podList.size() > 0) {
                                for (int i = 0; i < podList.size(); i++) {
                                    V1Pod curV1Pod = podList.get(i);
                                    //查询该容器在那个节点上
                                    String nodeIp = curV1Pod.getSpec().getNodeName();
                                    String jobName = curV1Pod.getMetadata().getName().substring(0, curV1Pod.getMetadata().getName().lastIndexOf("-"));
                                    if (currentJobName.equals(jobName)) {
                                        //Pending 等待中 Running 运行中 Succeeded 正常终止 Failed 异常停止 Unkonwn 未知状态 Completed 已完成
                                        String phaseStatus = curV1Pod.getStatus().getPhase();
                                        if (!status.equals(phaseStatus)) {
                                            gdaiTrainingModelService.trainingModelFinish(model);
                                            buildCntrMsg(phaseStatus, model, k8sClientOperator);
                                            gdaiTrainingModelMapper.updateById(model);
                                            Date date = new Date();
                                            GdaiTrainingModel trainingModel = new GdaiTrainingModel(trainId, phaseStatus, date);
                                            gdaiTrainingModelMapper.updateById(trainingModel);
                                            //                                                //状态不为Pending和Running表示任务已结束
                                            //                                                if (!"Pending".equals(phaseStatus) && !"Running".equals(phaseStatus)) {
                                            //                                                    //根据项目ID查询项目资源情况
                                            //                                                    GdaiProject gdaiProject = gdaiProjectMapper.selectById(projectId);
                                            //                                                    if (gdaiProject != null) {
                                            //                                                        //释放配额
                                            //                                                        gdaiProjectService.releaseProject(projectId, "train", model.getCore(), model.getMemorySize(), model.getGpuSize());
                                            //                                                        //释放资源
                                            //                                                        gdaiNodeInfoService.releaseNode(nodeIp, "train", model.getCore(), model.getMemorySize(), model.getGpuSize());
                                            //                                                    }
                                            //                                                }
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        log.info("metadataNamespace为空,trainId为: [{}]", trainId);
                    }
                }
            }
        }
    } catch (Exception e) {
        log.info("更新job状态异常：", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    log.info("更新job状态定时任务执行结束,结束时间：[{}]", DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS));
}
### 类导入的包
com.baomidou.mybatisplus.mapper.EntityWrapper
com.eshore.gdai.trainingcenter.entity.GdaiProject
com.eshore.gdai.trainingcenter.entity.GdaiTrainingModel
com.eshore.gdai.trainingcenter.util.DateUtil
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
org.springframework.transaction.interceptor.TransactionAspectSupport
java.util.ArrayList
java.util.Date
java.util.List
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;
@Resource
private K8sClientOperator k8sClientOperator;
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiTrainingModelService gdaiTrainingModelService;
@Resource
private GdaiProjectMapper gdaiProjectMapper;
@Resource
private GdaiNodeInfoServiceImpl gdaiNodeInfoService;
@Resource
private GdaiProjectServiceImpl gdaiProjectService;
/**
 * 当前运行进程的所在主机的IP
 */
@Value("${config.localhostip}")
private String localhostip;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task下的类GdaiTrainingModelTask中有一个名为buildCntrMsg的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void buildCntrMsg(String message, GdaiTrainingModel gdaiTrainingModel, K8sClientOperator k8sClientOperator) throws Exception {
    JSONObject object = new JSONObject();
    if (StringUtils.isNotEmpty(gdaiTrainingModel.getCntrMsg())) {
        object = JSON.parseObject(gdaiTrainingModel.getCntrMsg());
    }
    object.put("message", message);
    if (StringUtils.isEmpty(gdaiTrainingModel.getPodName())) {
        V1PodList curV1PodList = k8sClientOperator.listNamespacedPod(gdaiTrainingModel.getNameSpace(), gdaiTrainingModel.getPodLabelSelector());
        if (curV1PodList != null && !curV1PodList.getItems().isEmpty()) {
            gdaiTrainingModel.setPodName(curV1PodList.getItems().get(0).getMetadata().getName());
        }
    }
    if (StringUtils.isNotEmpty(gdaiTrainingModel.getPodName())) {
        List<Event> events = k8sClientOperator.getEvents(gdaiTrainingModel.getNameSpace(), gdaiTrainingModel.getPodName());
        if (events != null) {
            object.put("event", events);
        }
    }
    if (StringUtils.isNotEmpty(gdaiTrainingModel.getNameSpace())) {
        ContainerState state = k8sClientOperator.getContainerState(gdaiTrainingModel.getNameSpace(), gdaiTrainingModel.getPodLabelSelector());
        if (state != null) {
            object.put("state", state);
        }
    }
    gdaiTrainingModel.setCntrMsg(JSON.toJSONString(object));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.models.V1Pod
io.kubernetes.client.openapi.models.V1PodList
org.apache.commons.lang3.StringUtils
java.util.List
### 类级别的变量
@Resource
private K8sClientOperator k8sClientOperator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiAutoTrainingAsyncTask中有一个名为startAutoTraining的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startAutoTraining(GdaiAutoTraining gdaiAutoTraining) {
    try {
        gdaiAutoTrainingService.createJobTemplateV2(gdaiAutoTraining);
        gdaiAutoTrainingMapper.updateById(gdaiAutoTraining);
    } catch (Exception e) {
        log.info("部署异常", e);
        String cntrMsg = e.getMessage();
        if (e.getMessage() != null && e.getMessage().length() > 200) {
            cntrMsg = e.getMessage().substring(0, 200);
        }
        gdaiAutoTraining.setCntrMsg(cntrMsg);
        gdaiAutoTraining.setStatus("Unkonwn");
        gdaiAutoTrainingMapper.updateById(gdaiAutoTraining);
    }
}
### 类导入的包

### 类级别的变量
@Resource
private GdaiAutoTrainingMapper gdaiAutoTrainingMapper;
@Resource
private GdaiAutoTrainingService gdaiAutoTrainingService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiAutoTrainingAsyncTask中有一个名为startAutoDeploy的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startAutoDeploy(GdaiModelDeploy gdaiModelDeploy) {
    try {
        gdaiAutoTrainingService.createPubContainerV2(gdaiModelDeploy);
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
    } catch (Exception e) {
        log.info("部署异常", e);
        String cntrMsg = e.getMessage();
        if (e.getMessage() != null && e.getMessage().length() > 200) {
            cntrMsg = e.getMessage().substring(0, 200);
        }
        gdaiModelDeploy.setPubCntrMsg(cntrMsg);
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
    }
}
### 类导入的包

### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiAutoTrainingService gdaiAutoTrainingService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiDatafileAsyncTask中有一个名为startSaveDataFileInfo的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startSaveDataFileInfo(GdaiDatafileVo gdaiDatafileVo) {
    log.info("GdaiDatafileAsyncTask.startSaveDataFileInfo params: {}", JSON.toJSONString(gdaiDatafileVo));
    Long datasetId = gdaiDatafileVo.getDatasetId();
    String dataType = gdaiDatafileVo.getDataType();
    String markStatus = gdaiDatafileVo.getMarkStatus();
    String datasetCephPath = gdaiDatafileVo.getDatasetCephPath();
    String filePath = gdaiDatafileVo.getFilePath();
    String confFilePath = gdaiDatafileVo.getConfFilePath();
    String fileName = gdaiDatafileVo.getName();
    Long creatorId = gdaiDatafileVo.getCreatorId();
    //默认解析失败
    boolean isParsedSuccessfully = false;
    try {
        long startTime = System.currentTimeMillis();
        RestResult restResult = handleFileType(dataType, datasetId, markStatus, datasetCephPath, creatorId, filePath, confFilePath, fileName);
        if ("200".equals(restResult.getCode())) {
            isParsedSuccessfully = true;
            log.info("解析文件成功");
        } else {
            log.info("解析文件失败，失败原因：{}", restResult.getMessage());
        }
        long endTime = System.currentTimeMillis();
        float excTime = (float) (endTime - startTime) / 1000;
        log.info("解析文件完毕，总耗时：{}秒", excTime);
    } catch (Exception e) {
        log.error("解析文件异常", e);
    } finally {
        //随手删除重命名失败的临时文件
        FileUtil.deleteTempFile(filePath);
    }
    //全部导入完毕修改数据集导入状态：已完成-S0I，导入失败-S0F
    updateDatasetImportStatus(datasetId, isParsedSuccessfully);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.util.FileUtil
org.springframework.scheduling.annotation.Async
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiDatafileAsyncTask中有一个名为handleFileType的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private RestResult handleFileType(String dataType, Long datasetId, String markStatus, String datasetCephPath, Long creatorId, String filePath, String confFilePath, String fileName) {
    switch(dataType.toLowerCase(Locale.ROOT)) {
        case "pic":
            return gdaiDatafileServiceImpl.uploadPicMethod(datasetId, markStatus, dataType, datasetCephPath, creatorId, filePath, confFilePath, fileName);
        case "txt":
            return gdaiDatafileServiceImpl.uploadTxtMethod(datasetId, markStatus, dataType, datasetCephPath, creatorId, filePath, confFilePath, fileName);
        case "video":
            return gdaiDatafileServiceImpl.uploadVideoMethod(datasetId, markStatus, dataType, datasetCephPath, creatorId, filePath, confFilePath, fileName);
        default:
            log.info("数据集类型错误: {}", dataType);
            throw new IllegalArgumentException("Unsupported data type: " + dataType);
    }
}
### 类导入的包
java.util.Locale
### 类级别的变量
@Resource
private GdaiDatafileServiceImpl gdaiDatafileServiceImpl;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiDatafileAsyncTask中有一个名为updateDatasetImportStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private void updateDatasetImportStatus(Long datasetId, boolean isParsedSuccessfully) {
    GdaiDataset set = new GdaiDataset();
    set.setDatasetId(datasetId);
    set.setModifyTime(new Date());
    set.setImpStatus(isParsedSuccessfully ? "S0I" : "S0F");
    gdaiDatasetMapper.updateById(set);
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDataset
java.util.Date
### 类级别的变量
@Resource
private GdaiDatasetMapper gdaiDatasetMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiDeployModelAsyncTask中有一个名为startDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startDeployModel(GdaiModelDeploy gdaiModelDeploy) {
    try {
        if (StringUtils.isNotEmpty(gdaiModelDeploy.getContext())) {
            //                //TBD 存量的项目创建namespace
            //                gdaiModelDeployService.createNamespaceIfNotExist(gdaiModelDeploy);
            //1、build yaml
            gdaiModelDeployService.buildYmlContent(gdaiModelDeploy);
            //2、创建deployment
            gdaiModelDeployService.createDeployment(gdaiModelDeploy);
            //3、创建Service
            gdaiModelDeployService.createService(gdaiModelDeploy);
            //4、更新数据库信息
            gdaiModelDeploy.setStatus("S2C");
            gdaiModelDeploy.setModifyTime(new Date());
            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        } else {
            throw new Exception("旧的部署方式不再支持");
            //                gdaiModelDeploy.setContext("{}");
            //                gdaiModelDeployService.createPubContainer(gdaiModelDeploy);
            //                gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        }
    } catch (Exception e) {
        log.info("部署异常", e);
        String cntrMsg = e.getMessage();
        if (e.getMessage() != null && e.getMessage().length() > 200) {
            cntrMsg = e.getMessage().substring(0, 200);
        }
        gdaiModelDeploy.setPubCntrMsg(cntrMsg);
        gdaiModelDeploy.setStatus("S2E");
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
    }
}
### 类导入的包
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiDeployModelAsyncTask中有一个名为startReplaceDeployModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startReplaceDeployModel(GdaiModelDeploy gdaiModelDeploy) {
    try {
        if (StringUtils.isNotEmpty(gdaiModelDeploy.getContext())) {
            //1、build yaml
            gdaiModelDeployService.buildYmlContent(gdaiModelDeploy);
            //2、创建deployment
            gdaiModelDeployService.replaceDeployment(gdaiModelDeploy);
            //4、更新数据库信息
            gdaiModelDeploy.setStatus("S2C");
            gdaiModelDeploy.setModifyTime(new Date());
            gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        } else {
            throw new Exception("旧的部署方式不再支持");
            //                gdaiModelDeployService.replacePubContainer(gdaiModelDeploy);
            //                gdaiModelDeployMapper.updateById(gdaiModelDeploy);
        }
    } catch (Exception e) {
        log.info("部署异常", e);
        String cntrMsg = e.getMessage();
        if (e.getMessage() != null && e.getMessage().length() > 200) {
            cntrMsg = e.getMessage().substring(0, 200);
        }
        gdaiModelDeploy.setPubCntrMsg(cntrMsg);
        gdaiModelDeploy.setStatus("S2E");
        gdaiModelDeployMapper.updateById(gdaiModelDeploy);
    }
}
### 类导入的包
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiModelDeployMapper gdaiModelDeployMapper;
@Resource
private GdaiModelDeployService gdaiModelDeployService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiDevModelAsyncTask中有一个名为create的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void create(String msg) {
    log.info("dev-model-executor: {}", msg);
    GdaiDevModel gdaiDevModel = new GdaiDevModel();
    gdaiDevModel.setDevName(msg);
    gdaiDevModel.setCreatorId(1L);
    try {
        log.info("创建deploy:{}", msg);
        Thread.sleep(1 * 10 * 1000);
        //            gdaiDevModelMapper.insert(gdaiDevModel);
        log.info("创建deploy:{}成功 ", msg);
        throw new RuntimeException("创建失败");
    } catch (Exception e) {
        log.error("error message :" + e.getMessage());
        gdaiDevModel.setCntrMsg(e.getMessage());
        //            gdaiDevModelMapper.updateById(gdaiDevModel);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiDevModel
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiDevModelAsyncTask中有一个名为startDevModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startDevModel(GdaiDevModel gdaiDevModel) {
    try {
        if (StringUtils.isNotEmpty(gdaiDevModel.getContext())) {
            //1、build yaml
            gdaiDevModelService.buildYmlContent(gdaiDevModel);
            //2、创建deployment
            gdaiDevModelService.createDeployment(gdaiDevModel);
            //3、创建Service
            gdaiDevModelService.createService(gdaiDevModel);
            //4、更新数据库信息
            gdaiDevModel.setStatus("S0C");
            gdaiDevModel.setModifyTime(new Date());
            gdaiDevModelMapper.updateById(gdaiDevModel);
        } else {
            gdaiDevModel.setContext("{}");
            gdaiDevModelService.createContainer(gdaiDevModel);
            gdaiDevModelMapper.updateById(gdaiDevModel);
        }
    } catch (Exception e) {
        log.info("部署异常", e);
        String cntrMsg = e.getMessage();
        if (e.getMessage() != null && e.getMessage().length() > 200) {
            cntrMsg = e.getMessage().substring(0, 200);
        }
        JSONObject message = new JSONObject();
        message.put("message", cntrMsg);
        gdaiDevModel.setCntrMsg(JSONObject.toJSONString(message));
        gdaiDevModel.setStatus("S0E");
        gdaiDevModelMapper.updateById(gdaiDevModel);
    }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiDevModelMapper gdaiDevModelMapper;
@Resource
private GdaiDevModelService gdaiDevModelService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiHarborImageAsyncTask中有一个名为startPushImage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startPushImage(GdaiHarborImageVo gdaiHarborImageVo) {
    Long harborImageId = gdaiHarborImageVo.getHarborImageId();
    String fileName = gdaiHarborImageVo.getFileName();
    String imageName = gdaiHarborImageVo.getImageName();
    String imagePath = gdaiHarborImageVo.getImagePath();
    String tempDir = gdaiHarborImageVo.getTempDir();
    String tag = gdaiHarborImageVo.getTag();
    Long creatorId = gdaiHarborImageVo.getCreatorId();
    tag = tag.toLowerCase().trim();
    try {
        //对原文件名进行拆分
        String name;
        String ext;
        String extension = FilenameUtils.getExtension(fileName);
        if ("gz".equalsIgnoreCase(extension)) {
            ext = fileName.substring(fileName.length() - 7);
        } else if ("tar".equalsIgnoreCase(extension)) {
            ext = fileName.substring(fileName.length() - 4);
        } else {
            throw new Exception("不支持该类型镜像压缩包");
        }
        //拼装镜像全路径
        File imageZipPath = FileUtils.getFile(tempDir + "/" + fileName);
        log.info("镜像压缩包全路径: " + imageZipPath.getAbsolutePath());
        //获取镜像repoTags
        String repoTags = getImageRepoTags(ext, imageZipPath);
        if (StringUtils.isBlank(repoTags)) {
            log.info("获取镜像repoTags失败");
            throw new Exception("获取镜像repoTags失败");
        }
        //拼装镜像名称
        String newImageName = IP + ":" + PORT + "/" + imagePath + imageName + ":" + tag;
        //落库新镜像名称
        String newImageName2 = IP + ":" + PORT + "/" + imagePath + imageName;
        //SPS-镜像推送中 SPE-镜像推送完毕 SPF-镜像推送异常
        boolean bo = gdaiHarborImageService.pushImageToHarbor(imageZipPath, newImageName, repoTags, tag, HARBOR_LOGIN_ADDRESS, HARBOR_USERNAME, HARBOR_PASSWORD);
        if (bo) {
            log.info("镜像推送成功");
            gdaiHarborImageMapper.updateById(new GdaiHarborImage(harborImageId, newImageName2, "SPE", creatorId, new Date()));
        }
    } catch (Exception e) {
        log.info("镜像推送异常：", e);
        gdaiHarborImageMapper.updateById(new GdaiHarborImage(harborImageId, "SPF", e.getMessage(), new Date()));
    } finally {
        //上传完毕删除临时文件及文件夹
        String substring = tempDir.substring(0, tempDir.lastIndexOf("fileManager"));
        File filePath = FileUtils.getFile(substring);
        if (filePath.exists()) {
            FileUtil.deleteFile(filePath);
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.util.FileUtil
org.apache.commons.io.FileUtils
org.apache.commons.io.FilenameUtils
org.apache.commons.lang3.StringUtils
java.io.File
java.util.Date
### 类级别的变量
@Resource
private GdaiHarborImageService gdaiHarborImageService;
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;
/**
 * Harbor登录用户名
 */
@Value("${harbor.username}")
private String HARBOR_USERNAME;
/**
 * 登录密码
 */
@Value("${harbor.password}")
private String HARBOR_PASSWORD;
/**
 * Harbor的登录地址
 */
@Value("${harbor.login_address}")
private String HARBOR_LOGIN_ADDRESS;
/**
 * Harbor的登录地址
 */
@Value("${harbor.ip}")
private String IP;
/**
 * Harbor的登录地址
 */
@Value("${harbor.port}")
private String PORT;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiHarborImageAsyncTask中有一个名为startCatFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startCatFile(GdaiHarborImageVo gdaiHarborImageVo) {
    Long harborImageId = gdaiHarborImageVo.getHarborImageId();
    String md5 = gdaiHarborImageVo.getMd5();
    String tempDir = gdaiHarborImageVo.getTempDir();
    String partPrefix = gdaiHarborImageVo.getPartPrefix();
    String fileName = gdaiHarborImageVo.getFileName();
    String ext = gdaiHarborImageVo.getExt();
    List<String> fileNameList = gdaiHarborImageVo.getFileNameList();
    String mergedFilePath = tempDir + File.separator + fileName + "." + ext;
    try {
        long startTime = System.currentTimeMillis();
        // 构建命令
        String command = "sudo cat " + tempDir + File.separator + partPrefix + "*" + " > " + mergedFilePath;
        log.info("Executing command: " + command);
        ProcessBuilder processBuilder = new ProcessBuilder("sh", "-c", command);
        // 启动进程并等待执行完成
        Process process = processBuilder.start();
        int exitCode = process.waitFor();
        if (exitCode == 0) {
            log.info("Files merged successfully");
            String catMd5 = calculateAndLogMd5(mergedFilePath);
            if (md5.equals(catMd5)) {
                log.info("文件MD5校验通过");
                deleteTempFilesAndUpdateStatus(fileNameList, tempDir, harborImageId, "SCS");
                long endTime = System.currentTimeMillis();
                float excTime = (float) (endTime - startTime) / 1000;
                log.info("文件合并校验完毕，总耗时：" + excTime + "秒");
            } else {
                handleMergeFailure("文件MD5校验不通过", mergedFilePath, harborImageId, "SCE");
            }
        } else {
            handleMergeFailure("文件合并失败: " + exitCode, mergedFilePath, harborImageId, "SFE");
        }
    } catch (IOException | InterruptedException e) {
        handleMergeFailure("文件合并异常: " + e.getMessage(), mergedFilePath, harborImageId, "SFE");
    }
}
### 类导入的包
java.io.File
java.io.IOException
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiHarborImageAsyncTask中有一个名为calculateAndLogMd5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private String calculateAndLogMd5(String filePath) {
    String md5 = GdaiHarborImageServiceImpl.calculateMD5(filePath);
    if (StringUtils.isNotBlank(md5)) {
        log.info("MD5 of merged file: " + md5);
        return md5;
    } else {
        log.info("获取文件MD5失败");
        return null;
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.service.GdaiHarborImageService
com.eshore.gdai.trainingcenter.service.impl.GdaiHarborImageServiceImpl
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiHarborImageAsyncTask中有一个名为deleteTempFilesAndUpdateStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private void deleteTempFilesAndUpdateStatus(List<String> fileNameList, String tempDir, Long harborImageId, String status) {
    for (String partFileName : fileNameList) {
        String tempPath = tempDir + File.separator + partFileName;
        log.info("Deleting temporary file: " + tempPath);
        FileUtil.deleteFile(tempPath);
    }
    gdaiHarborImageMapper.updateById(new GdaiHarborImage(harborImageId, status, new Date()));
}
### 类导入的包
com.eshore.gdai.trainingcenter.entity.GdaiHarborImage
com.eshore.gdai.trainingcenter.util.FileUtil
java.io.File
java.util.Date
java.util.List
### 类级别的变量
@Resource
private GdaiHarborImageMapper gdaiHarborImageMapper;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiHarborImageAsyncTask中有一个名为getImageRepoTags的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取镜像压缩包中的镜像RepoTags
     *
     * @param ext
     * @param file
     * @return
     * @throws Exception
     */
public static String getImageRepoTags(String ext, File file) throws Exception {
    if (".tar".equalsIgnoreCase(ext)) {
        return getImageRepoTagsByTar(file);
    } else if (".tar.gz".equalsIgnoreCase(ext)) {
        return getImageRepoTagsByTarGz(file);
    } else {
        throw new Exception("不支持该类型镜像压缩包");
    }
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiHarborImageAsyncTask中有一个名为getImageRepoTagsByTar的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String getImageRepoTagsByTar(File file) throws IOException {
    try (FileInputStream fis = new FileInputStream(file);
        TarInputStream tin = new TarInputStream(fis)) {
        TarEntry entry;
        while ((entry = tin.getNextEntry()) != null) {
            String entryName = entry.getName();
            if ("manifest.json".equals(entryName)) {
                JsonNode manifestJson = objectMapper.readTree(tin);
                JsonNode repoTags = manifestJson.get(0).get("RepoTags");
                if (repoTags.isArray() && repoTags.size() > 0) {
                    // 取第一个RepoTag
                    return repoTags.get(0).asText();
                }
                throw new IOException("RepoTags not found or empty in manifest.json");
            }
        }
        throw new IOException("manifest.json not found in the tar file");
    }
}
### 类导入的包
com.fasterxml.jackson.databind.JsonNode
org.apache.tools.tar.TarEntry
org.apache.tools.tar.TarInputStream
java.io.File
java.io.FileInputStream
java.io.IOException
### 类级别的变量
private static final ObjectMapper objectMapper = new ObjectMapper();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiHarborImageAsyncTask中有一个名为getImageRepoTagsByTarGz的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String getImageRepoTagsByTarGz(File file) throws IOException {
    try (FileInputStream fis = new FileInputStream(file);
        TarArchiveInputStream tin = new TarArchiveInputStream(new GzipCompressorInputStream(fis))) {
        TarArchiveEntry entry;
        while ((entry = tin.getNextTarEntry()) != null) {
            String entryName = entry.getName();
            if ("manifest.json".equals(entryName)) {
                JsonNode manifestJson = objectMapper.readTree(tin);
                JsonNode repoTags = manifestJson.get(0).get("RepoTags");
                if (repoTags.isArray() && repoTags.size() > 0) {
                    // 取第一个RepoTag
                    return repoTags.get(0).asText();
                }
                throw new IOException("RepoTags not found or empty in manifest.json");
            }
        }
        throw new IOException("manifest.json not found in the tar.gz file");
    }
}
### 类导入的包
com.fasterxml.jackson.databind.JsonNode
org.apache.commons.compress.archivers.tar.TarArchiveEntry
org.apache.commons.compress.archivers.tar.TarArchiveInputStream
org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
org.apache.tools.tar.TarEntry
java.io.File
java.io.FileInputStream
java.io.IOException
### 类级别的变量
private static final ObjectMapper objectMapper = new ObjectMapper();

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.task.async下的类GdaiTrainingModelAsyncTask中有一个名为startTrainingModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void startTrainingModel(GdaiTrainingModel gdaiTrainingModel) {
    try {
        if (StringUtils.isNotEmpty(gdaiTrainingModel.getContext())) {
            //1、build yaml
            gdaiTrainingModelService.buildYmlContent(gdaiTrainingModel);
            //2、创建deployment
            gdaiTrainingModelService.createJob(gdaiTrainingModel);
            //4、更新数据库信息
            gdaiTrainingModel.setStatus("Pending");
            gdaiTrainingModel.setModifyTime(new Date());
            gdaiTrainingModelMapper.updateById(gdaiTrainingModel);
        } else {
            throw new Exception("旧的训练方式不再支持");
            //                gdaiTrainingModel.setContext("{}");
            //                gdaiTrainingModelService.createJobTemplate(gdaiTrainingModel);
            //                gdaiTrainingModelMapper.updateById(gdaiTrainingModel);
        }
    } catch (Exception e) {
        log.info("部署异常", e);
        gdaiTrainingModelMapper.updateById(gdaiTrainingModel);
    }
}
### 类导入的包
org.apache.commons.lang3.StringUtils
java.util.Date
### 类级别的变量
@Resource
private GdaiTrainingModelMapper gdaiTrainingModelMapper;
@Resource
private GdaiTrainingModelService gdaiTrainingModelService;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为validateAlgorithmZip的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void validateAlgorithmZip(String zipFilePath) throws IOException {
    // Step 1: Check if the file has .zip extension
    if (!zipFilePath.toLowerCase(Locale.ROOT).endsWith(".zip")) {
        throw new IOException("算法压缩包不是zip类型");
    }
    // Step 2: Get top level directories
    Set<String> set = new HashSet<>();
    Set<String> topLevelDirectories = getTopLevelDirectories(zipFilePath);
    String[] requiredDirectories = { "task-logo", "task-cloud-private", "task-image", "task-md", "task-metadata" };
    if (topLevelDirectories.size() == 1) {
        String topLevelDirectory = topLevelDirectories.iterator().next();
        Set<String> secondLevelDirectories = getSecondLevelDirectories(zipFilePath, topLevelDirectory);
        System.out.println("Top level directory: " + topLevelDirectory);
        System.out.println("\tSecond level directories:");
        for (String subDirectory : secondLevelDirectories) {
            if (Arrays.asList(requiredDirectories).contains(subDirectory)) {
                set.add(subDirectory);
                System.out.println("\t" + subDirectory);
            }
        }
    } else {
        System.out.println("Multiple top level directories found:");
        for (String directory : topLevelDirectories) {
            if (Arrays.asList(requiredDirectories).contains(directory)) {
                set.add(directory);
                System.out.println("\t" + directory);
            }
        }
    }
    // Step 3: Check if the top level directories contain required directories
    validateRequiredDirectories(set);
    // Step 4: Check task-logo directory
    validateTaskLogoDirectory(zipFilePath, set);
    // Step 5: Check task-image directory
    validateTaskImageDirectory(zipFilePath, set);
    // Step 6: Check task-metadata directory
    validateTaskMetadataDirectory(zipFilePath, set);
}
### 类导入的包
java.io.IOException
java.util.Arrays
java.util.HashSet
java.util.List
java.util.Locale
java.util.Set
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为validateRequiredDirectories的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void validateRequiredDirectories(Set<String> topLevelDirectories) throws IOException {
    List<String> requiredDirectories = Arrays.asList("task-logo", "task-cloud-private", "task-image", "task-md", "task-metadata");
    for (String requiredDir : requiredDirectories) {
        if (!topLevelDirectories.contains(requiredDir)) {
            throw new IOException("缺少指定目录: " + requiredDir);
        }
    }
}
### 类导入的包
java.io.IOException
java.util.Arrays
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为validateTaskLogoDirectory的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void validateTaskLogoDirectory(String zipFilePath, Set<String> topLevelDirectories) throws IOException {
    String taskLogoDir = "task-logo";
    if (!topLevelDirectories.contains(taskLogoDir)) {
        throw new IOException("缺少指定目录：task-logo");
    }
    Set<String> imageTypes = new HashSet<>(Arrays.asList("gif", "jfif", "pjpeg", "jpeg", "pjp", "jpg", "png"));
    // Flag to track if at least one image file is found
    boolean imageFound = false;
    try (ZipFile zipFile = new ZipFile(zipFilePath)) {
        Enumeration<? extends ZipEntry> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            if (!entry.isDirectory()) {
                String entryName = entry.getName();
                if (entryName.contains(taskLogoDir + "/")) {
                    String extension = getFileExtension(entryName);
                    if (imageTypes.contains(extension.toLowerCase())) {
                        // Found at least one image file
                        imageFound = true;
                        // Exit the loop since we found an image file
                        break;
                    }
                }
            }
        }
    }
    if (!imageFound) {
        // No image file found
        throw new IOException("task-logo目录下缺少指定类型的图片文件(仅支持gif, jfif, pjpeg, jpeg, pjp, jpg, png类型图片)");
    }
}
### 类导入的包
java.io.IOException
java.util.Arrays
java.util.Enumeration
java.util.HashSet
java.util.List
java.util.Set
java.util.zip.ZipEntry
java.util.zip.ZipFile
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为validateTaskImageDirectory的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void validateTaskImageDirectory(String zipFilePath, Set<String> topLevelDirectories) throws IOException {
    // 注意这里添加了斜杠，以匹配ZIP中的目录结构
    String taskImageDir = "task-image";
    if (!topLevelDirectories.contains(taskImageDir)) {
        throw new IOException("缺少指定目录：task-image");
    }
    // 匹配用户名#镜像名称#版本号.tar格式的命名
    boolean tarFileFound = false;
    Pattern tarPattern = Pattern.compile("^[^#]+#[^#]+#[^#\\.]+\\.tar$");
    try (ZipFile zipFile = new ZipFile(zipFilePath)) {
        Enumeration<? extends ZipEntry> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            String entryName = entry.getName();
            // 只检查task-image目录下的文件
            if (entryName.contains(taskImageDir) && !entry.isDirectory()) {
                // 检查文件扩展名是否为.tar
                if (entryName.endsWith(".tar")) {
                    // 去除task-image/前缀，并检查剩余部分是否符合命名规范
                    // 获取文件名，不包括路径部分
                    int lastSlashIndex = entryName.lastIndexOf('/');
                    String fileName = entryName.substring(lastSlashIndex + 1);
                    if (tarPattern.matcher(fileName).matches()) {
                        // 符合命名规范的.tar文件被找到
                        tarFileFound = true;
                        // 如果只需要找到一个符合规范的.tar文件，则可以跳出循环
                        break;
                    }
                }
            }
        }
    }
    if (!tarFileFound) {
        throw new IOException("task-image目录下缺少.tar结尾的镜像文件或镜像文件命名不规范（用户名#镜像名称#版本号.tar 以='#'分割）");
    }
}
### 类导入的包
java.io.IOException
java.util.Enumeration
java.util.regex.Pattern
java.util.zip.ZipEntry
java.util.zip.ZipFile
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为validateTaskMetadataDirectory的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void validateTaskMetadataDirectory(String zipFilePath, Set<String> topLevelDirectories) throws IOException {
    String taskMetadataDir = "task-metadata";
    if (!topLevelDirectories.contains(taskMetadataDir)) {
        throw new IOException("缺少指定目录：task-metadata");
    }
    try (ZipFile zipFile = new ZipFile(zipFilePath)) {
        Enumeration<? extends ZipEntry> entries = zipFile.entries();
        boolean metadataJsonFound = false;
        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            String entryName = entry.getName();
            if (!entry.isDirectory() && entryName.contains(taskMetadataDir) && entryName.endsWith("metadata.json")) {
                ObjectMapper mapper = new ObjectMapper();
                try (java.io.InputStream inputStream = zipFile.getInputStream(entry)) {
                    JsonNode jsonNode = mapper.readTree(inputStream);
                    if (!(jsonNode instanceof ObjectNode)) {
                        throw new IOException("metadata.json不是一个JSON对象");
                    }
                    //                        ObjectNode objectNode = (ObjectNode) jsonNode;
                    //
                    //                        if (!objectNode.has("RepoTags")) {
                    //                            throw new IOException("metadata.json文件缺少指定字段: RepoTags");
                    //                        }
                    metadataJsonFound = true;
                } catch (JsonParseException e) {
                    throw new IOException("metadata.json文件中json格式存在错误: " + e.getMessage());
                }
            }
        }
        if (!metadataJsonFound) {
            throw new IOException("task-metadata目录下缺少指定文件：metadata.json");
        }
    }
}
### 类导入的包
com.fasterxml.jackson.core.JsonParseException
com.fasterxml.jackson.databind.JsonNode
com.fasterxml.jackson.databind.ObjectMapper
com.fasterxml.jackson.databind.node.ObjectNode
java.io.IOException
java.util.Enumeration
java.util.zip.ZipEntry
java.util.zip.ZipFile
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为getFileExtension的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private static String getFileExtension(String fileName) {
    int dotIndex = fileName.lastIndexOf('.');
    if (dotIndex == -1 || dotIndex == fileName.length() - 1) {
        // No extension found
        return "";
    }
    return fileName.substring(dotIndex + 1);
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为getTopLevelDirectories的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Set<String> getTopLevelDirectories(String zipFilePath) throws IOException {
    Set<String> topLevelDirectories = new HashSet<>();
    try (ZipFile zipFile = new ZipFile(zipFilePath)) {
        Enumeration<? extends ZipEntry> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            if (entry.isDirectory()) {
                String directoryName = entry.getName();
                int index = directoryName.indexOf('/');
                if (index != -1) {
                    directoryName = directoryName.substring(0, index);
                    topLevelDirectories.add(directoryName);
                }
            }
        }
    }
    return topLevelDirectories;
}
### 类导入的包
java.util.Enumeration
java.util.HashSet
java.util.Set
java.util.zip.ZipEntry
java.util.zip.ZipFile
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AlgorithmZipValidator中有一个名为getSecondLevelDirectories的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Set<String> getSecondLevelDirectories(String zipFilePath, String topLevelDirectory) throws IOException {
    Set<String> secondLevelDirectories = new HashSet<>();
    try (ZipFile zipFile = new ZipFile(zipFilePath)) {
        Enumeration<? extends ZipEntry> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            if (entry.isDirectory()) {
                String directoryName = entry.getName();
                int index = directoryName.indexOf('/');
                if (index != -1) {
                    String parentDirectory = directoryName.substring(0, index);
                    if (parentDirectory.equals(topLevelDirectory)) {
                        int nextSlashIndex = directoryName.indexOf('/', index + 1);
                        if (nextSlashIndex != -1) {
                            String subDirectoryName = directoryName.substring(index + 1, nextSlashIndex);
                            secondLevelDirectories.add(subDirectoryName);
                        }
                    }
                }
            }
        }
    }
    return secondLevelDirectories;
}
### 类导入的包
java.util.Enumeration
java.util.HashSet
java.util.Set
java.util.zip.ZipEntry
java.util.zip.ZipFile
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AuthIcspUtils中有一个名为requestIcsp的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 请求ICSP平台
     *
     * @param path
     * @param body
     * @return
     * @throws IOException
     */
public static String requestIcsp(String path, JSONObject body) throws IOException {
    log.info("请求ICSP平台参数集：{}", JSON.toJSONString(body));
    //headers
    String taskReqId = null;
    if (body != null && body.containsKey("taskReqId")) {
        taskReqId = body.getString("taskReqId");
    }
    Map<String, String> headers = getHeaders(taskReqId);
    String json = HttpUtils.doPostJson(URL + path, headers, body);
    log.info("返回ICSP平台参数集：{}", json);
    return json;
}
### 类导入的包
com.alibaba.fastjson.JSON
com.chinatelecom.dcoos.common.utils.HttpUtils
java.util.Map
### 类级别的变量
private static String URL;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AuthIcspUtils中有一个名为getHeaders的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取请求头
     *
     * @return
     */
private static Map<String, String> getHeaders(String taskReqId) {
    Map<String, String> headers = new HashMap<>();
    String timestamp = String.valueOf(System.currentTimeMillis());
    headers.put("Content-Type", "application/json;charset=UTF-8");
    headers.put("systemId", SYSTEM_ID);
    headers.put("sign", sign(timestamp, taskReqId));
    headers.put("timestamp", timestamp);
    return headers;
}
### 类导入的包
java.util.HashMap
java.util.Map
### 类级别的变量
//
private static String SYSTEM_ID;
@Value("${icsp.systemId}")
public String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AuthIcspUtils中有一个名为sign的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private static String sign(String timestamp, String taskReqId) {
    String saltMD5 = SecureUtil.md5(SALT);
    if (StringUtils.isEmpty(taskReqId)) {
        return SecureUtil.md5(SYSTEM_ID + saltMD5 + timestamp);
    } else {
        return SecureUtil.md5(SYSTEM_ID + saltMD5 + timestamp + taskReqId);
    }
}
### 类导入的包
cn.hutool.crypto.SecureUtil
org.apache.commons.lang3.StringUtils
### 类级别的变量
//
private static String SYSTEM_ID;
private static String SALT;
@Value("${icsp.salt}")
public String salt;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类AuthIcspUtils中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) throws IOException {
    JSONObject body = new JSONObject();
    body.put("systemId", "100000");
    body.put("productCode", "10");
    String result = AuthIcspUtils.requestIcsp("/ai/k8s/app/clusterList", body);
    System.out.println("result: " + JSON.toJSONString(result));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
### 类级别的变量
@Value("${icsp.systemId}")
public String systemId;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类CalculateUtils中有一个名为percentInstance的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 百分比计算
     *
     * @param detailTotalNumber
     * @param totalNumber
     * @return
     */
public static String percentInstance(Integer detailTotalNumber, Integer totalNumber, Integer min) {
    Double fileCount = Double.valueOf(detailTotalNumber);
    Double hasFlagCount = Double.valueOf(totalNumber);
    double percent;
    if (detailTotalNumber == 0 && totalNumber == 0) {
        percent = 0;
    } else {
        percent = fileCount / hasFlagCount;
    }
    //获取格式化对象
    NumberFormat nt = NumberFormat.getPercentInstance();
    //设置百分数精确度2即保留两位小数
    nt.setMinimumFractionDigits(min);
    return nt.format(percent);
}
### 类导入的包
java.text.NumberFormat
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类CommonTools中有一个名为checkDeletePermission的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Boolean checkDeletePermission(HttpServletRequest request, Long userId, Long creatorId) {
    // 判断用户是否是超级管理员
    boolean superAdminRole = SessionUtils.isSuperAdminRole(request);
    if (superAdminRole) {
        // 超级管理员具有删除权限
        return true;
    } else {
        // 非超级管理员，检查是否为创建者
        if (creatorId.equals(userId)) {
            // 当前用户是创建者，具有删除权限
            return true;
        } else {
            // 非创建者，无删除权限
            return false;
        }
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.utils.SessionUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类CommonTools中有一个名为isSuperAdminOrAiGroupAdmin的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Boolean isSuperAdminOrAiGroupAdmin(User user) {
    //AI团队管理员角色
    boolean aiGroupAdminRole = SessionUtils.isAiGroupAdminRole(user);
    //超级管理员角色
    boolean superAdminRole = SessionUtils.isSuperAdminRole(user);
    return aiGroupAdminRole || superAdminRole;
}
### 类导入的包
com.chinatelecom.dcoos.common.utils.SessionUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类CommonTools中有一个名为checkCommandAndArgs的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static boolean checkCommandAndArgs(String commandAndArgs) {
    String regex = "^(?:python(3?)\\s+)(?:/[\\w/]+\\.py|\\.?/[\\w/]+\\.py|\\w+\\.py)(?:\\s+(?:--.+=.+))*\\s*$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(commandAndArgs);
    if (matcher.matches() && !commandAndArgs.contains(";")) {
        return true;
    }
    return false;
}
### 类导入的包
java.util.regex.Matcher
java.util.regex.Pattern
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDay的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某日期的日数
     *
     * @param date
     * @return
     */
public static Integer getDay(Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    //获取日
    int day = cal.get(Calendar.DATE);
    return day;
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为parseDateToStr的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 格式化Date时间
     *
     * @param time         Date类型时间
     * @param timeFromat   String类型格式
     * @param defaultValue 默认值为当前时间Date
     * @return 格式化后的字符串
     */
public static String parseDateToStr(Date time, String timeFromat, final Date defaultValue) {
    try {
        DateFormat dateFormat = new SimpleDateFormat(timeFromat);
        return dateFormat.format(time);
    } catch (Exception e) {
        if (defaultValue != null) {
            return parseDateToStr(defaultValue, timeFromat);
        } else {
            return parseDateToStr(new Date(), timeFromat);
        }
    }
}
### 类导入的包
java.text.DateFormat
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为parseDateToStr的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 格式化Date时间
     *
     * @param time         Date类型时间
     * @param timeFromat   String类型格式
     * @param defaultValue 默认时间值String类型
     * @return 格式化后的字符串
     */
public static String parseDateToStr(Date time, String timeFromat, final String defaultValue) {
    try {
        DateFormat dateFormat = new SimpleDateFormat(timeFromat);
        return dateFormat.format(time);
    } catch (Exception e) {
        return defaultValue;
    }
}
### 类导入的包
java.text.DateFormat
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为parseStrToDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 格式化String时间
     *
     * @param time       String类型时间
     * @param timeFromat String类型格式
     * @return 格式化后的Date日期
     */
public static Date parseStrToDate(String time, String timeFromat) {
    if (StringUtils.isBlank(time)) {
        return null;
    }
    Date date = null;
    try {
        DateFormat dateFormat = new SimpleDateFormat(timeFromat);
        date = dateFormat.parse(time);
    } catch (Exception e) {
    }
    return date;
}
### 类导入的包
org.apache.commons.lang3.StringUtils
java.text.DateFormat
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为parseStrToDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 格式化String时间
     *
     * @param strTime      String类型时间
     * @param timeFromat   String类型格式
     * @param defaultValue 异常时返回的默认值
     * @return
     */
public static Date parseStrToDate(String strTime, String timeFromat, Date defaultValue) {
    try {
        DateFormat dateFormat = new SimpleDateFormat(timeFromat);
        return dateFormat.parse(strTime);
    } catch (Exception e) {
        return defaultValue;
    }
}
### 类导入的包
java.text.DateFormat
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为strToDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 当strTime为2008-9时返回为2008-9-1 00:00格式日期时间，无法转换返回null.
     *
     * @param strTime
     * @return
     */
public static Date strToDate(String strTime) {
    if (strTime == null || strTime.trim().length() <= 0) {
        return null;
    }
    Date date = null;
    List<String> list = new ArrayList<String>(0);
    list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);
    list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
    list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);
    list.add(DATE_TIME_FORMAT_YYYYMMDD_HH_MI);
    list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISS);
    list.add(DATE_FORMAT_YYYY_MM_DD);
    list.add(DATE_FORMAT_YYYYMMDD);
    list.add(DATE_FORMAT_YYYY_MM);
    list.add(DATE_FORMAT_YYYYMM);
    list.add(DATE_FORMAT_YYYY);
    for (Iterator iter = list.iterator(); iter.hasNext(); ) {
        String format = (String) iter.next();
        if ((strTime.indexOf("-") > 0 && format.indexOf("-") < 0)) {
            continue;
        }
        if ((strTime.indexOf("-") < 0 && format.indexOf("-") > 0)) {
            continue;
        }
        if (strTime.length() > format.length()) {
            continue;
        }
        date = parseStrToDate(strTime, format);
        if (date != null) {
            break;
        }
    }
    return date;
}
### 类导入的包
java.util.ArrayList
java.util.Date
java.util.Iterator
java.util.List
### 类级别的变量
/**
 * 日期格式，年份，例如：2004，2008
 */
public static final String DATE_FORMAT_YYYY = "yyyy";
/**
 * 日期格式，年份和月份，例如：200707，200808
 */
public static final String DATE_FORMAT_YYYYMM = "yyyyMM";
/**
 * 日期格式，年份和月份，例如：200707，2008-08
 */
public static final String DATE_FORMAT_YYYY_MM = "yyyy-MM";
/**
 * 日期格式，年月日，例如：20050630，20080808
 */
public static final String DATE_FORMAT_YYYYMMDD = "yyyyMMdd";
/**
 * 日期格式，年月日，用横杠分开，例如：2006-12-25，2008-08-08
 */
public static final String DATE_FORMAT_YYYY_MM_DD = "yyyy-MM-dd";
/**
 * 日期格式，年月日时分，例如：20001230 12:00，20080808 20:08
 */
public static final String DATE_TIME_FORMAT_YYYYMMDD_HH_MI = "yyyyMMdd HH:mm";
/**
 * 日期格式，年月日时分，例如：2000-12-30 12:00，2008-08-08 20:08
 */
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";
/**
 * 日期格式，年月日时分秒，例如：20001230120000，20080808200808
 */
public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISS = "yyyyMMddHHmmss";
/**
 * 日期格式，年月日时分秒，年月日用横杠分开，时分秒用冒号分开
 * 例如：2005-05-10 23：20：00，2008-08-08 20:08:08
 */
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";
/**
 * 日期格式，年月日时分秒毫秒，例如：20001230120000123，20080808200808456
 */
public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS = "yyyyMMddHHmmssSSS";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getMonthListOfDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 解析两个日期之间的所有月份
     *
     * @param beginDateStr 开始日期，至少精确到yyyy-MM
     * @param endDateStr   结束日期，至少精确到yyyy-MM
     * @return yyyy-MM日期集合
     */
public static List<String> getMonthListOfDate(String beginDateStr, String endDateStr) {
    // 指定要解析的时间格式
    SimpleDateFormat f = new SimpleDateFormat("yyyy-MM");
    // 返回的月份列表
    String sRet = "";
    // 定义一些变量
    Date beginDate = null;
    Date endDate = null;
    GregorianCalendar beginGC = null;
    GregorianCalendar endGC = null;
    List<String> list = new ArrayList<String>();
    try {
        // 将字符串parse成日期
        beginDate = f.parse(beginDateStr);
        endDate = f.parse(endDateStr);
        // 设置日历
        beginGC = new GregorianCalendar();
        beginGC.setTime(beginDate);
        endGC = new GregorianCalendar();
        endGC.setTime(endDate);
        // 直到两个时间相同
        while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
            sRet = beginGC.get(Calendar.YEAR) + "-" + (beginGC.get(Calendar.MONTH) + 1);
            list.add(sRet);
            // 以月为单位，增加时间
            beginGC.add(Calendar.MONTH, 1);
        }
        return list;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
### 类导入的包
java.text.DateFormat
java.text.SimpleDateFormat
java.util.ArrayList
java.util.Calendar
java.util.Date
java.util.GregorianCalendar
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDayListOfDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 解析两个日期段之间的所有日期
     *
     * @param beginDateStr 开始日期  ，至少精确到yyyy-MM-dd
     * @param endDateStr   结束日期  ，至少精确到yyyy-MM-dd
     * @return yyyy-MM-dd日期集合
     */
public static List<String> getDayListOfDate(String beginDateStr, String endDateStr) {
    // 指定要解析的时间格式
    SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
    // 定义一些变量
    Date beginDate = null;
    Date endDate = null;
    Calendar beginGC = null;
    Calendar endGC = null;
    List<String> list = new ArrayList<String>();
    try {
        // 将字符串parse成日期
        beginDate = f.parse(beginDateStr);
        endDate = f.parse(endDateStr);
        // 设置日历
        beginGC = Calendar.getInstance();
        beginGC.setTime(beginDate);
        endGC = Calendar.getInstance();
        endGC.setTime(endDate);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 直到两个时间相同
        while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
            list.add(sdf.format(beginGC.getTime()));
            // 以日为单位，增加时间
            beginGC.add(Calendar.DAY_OF_MONTH, 1);
        }
        return list;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
### 类导入的包
java.text.DateFormat
java.text.SimpleDateFormat
java.util.ArrayList
java.util.Calendar
java.util.Date
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getYearListOfYears的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取当下年份指定前后数量的年份集合
     *
     * @param before 当下年份前年数
     * @param behind 当下年份后年数
     * @return 集合
     */
public static List<Integer> getYearListOfYears(int before, int behind) {
    if (before < 0 || behind < 0) {
        return null;
    }
    List<Integer> list = new ArrayList<Integer>();
    Calendar c = null;
    c = Calendar.getInstance();
    c.setTime(new Date());
    int currYear = Calendar.getInstance().get(Calendar.YEAR);
    int startYear = currYear - before;
    int endYear = currYear + behind;
    for (int i = startYear; i < endYear; i++) {
        list.add(Integer.valueOf(i));
    }
    return list;
}
### 类导入的包
java.util.ArrayList
java.util.Calendar
java.util.Date
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getWeekthOfYear的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取当前日期是一年中第几周
     *
     * @param date
     * @return
     */
public static Integer getWeekthOfYear(Date date) {
    Calendar c = new GregorianCalendar();
    c.setFirstDayOfWeek(Calendar.MONDAY);
    c.setMinimalDaysInFirstWeek(7);
    c.setTime(date);
    return c.get(Calendar.WEEK_OF_YEAR);
}
### 类导入的包
java.util.Calendar
java.util.GregorianCalendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getWeekTimeOfYear的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某一年各星期的始终时间
     * 实例：getWeekList(2016)，第52周(从2016-12-26至2017-01-01)
     *
     * @param year
     * @return
     */
public static HashMap<Integer, String> getWeekTimeOfYear(int year) {
    HashMap<Integer, String> map = new LinkedHashMap<Integer, String>();
    Calendar c = new GregorianCalendar();
    c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
    int count = getWeekthOfYear(c.getTime());
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    String dayOfWeekStart = "";
    String dayOfWeekEnd = "";
    for (int i = 1; i <= count; i++) {
        dayOfWeekStart = sdf.format(getFirstDayOfWeek(year, i));
        dayOfWeekEnd = sdf.format(getLastDayOfWeek(year, i));
        map.put(Integer.valueOf(i), "第" + i + "周(从" + dayOfWeekStart + "至" + dayOfWeekEnd + ")");
    }
    return map;
}
### 类导入的包
java.text.DateFormat
java.text.SimpleDateFormat
java.util.Calendar
java.util.Date
java.util.GregorianCalendar
java.util.HashMap
java.util.LinkedHashMap
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getWeekCountOfYear的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某一年的总周数
     *
     * @param year
     * @return
     */
public static Integer getWeekCountOfYear(int year) {
    Calendar c = new GregorianCalendar();
    c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
    int count = getWeekthOfYear(c.getTime());
    return count;
}
### 类导入的包
java.util.Calendar
java.util.GregorianCalendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getFirstDayOfWeek的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取指定日期所在周的第一天
     *
     * @param date
     * @return
     */
public static Date getFirstDayOfWeek(Date date) {
    Calendar c = new GregorianCalendar();
    c.setFirstDayOfWeek(Calendar.MONDAY);
    c.setTime(date);
    // Monday
    c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
    return c.getTime();
}
### 类导入的包
java.util.Calendar
java.util.GregorianCalendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getLastDayOfWeek的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取指定日期所在周的最后一天
     *
     * @param date
     * @return
     */
public static Date getLastDayOfWeek(Date date) {
    Calendar c = new GregorianCalendar();
    c.setFirstDayOfWeek(Calendar.MONDAY);
    c.setTime(date);
    // Sunday
    c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
    return c.getTime();
}
### 类导入的包
java.util.Calendar
java.util.GregorianCalendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getFirstDayOfWeek的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某年某周的第一天
     *
     * @param year 目标年份
     * @param week 目标周数
     * @return
     */
public static Date getFirstDayOfWeek(int year, int week) {
    Calendar c = new GregorianCalendar();
    c.set(Calendar.YEAR, year);
    c.set(Calendar.MONTH, Calendar.JANUARY);
    c.set(Calendar.DATE, 1);
    Calendar cal = (GregorianCalendar) c.clone();
    cal.add(Calendar.DATE, week * 7);
    return getFirstDayOfWeek(cal.getTime());
}
### 类导入的包
java.util.Calendar
java.util.GregorianCalendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getLastDayOfWeek的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某年某周的最后一天
     *
     * @param year 目标年份
     * @param week 目标周数
     * @return
     */
public static Date getLastDayOfWeek(int year, int week) {
    Calendar c = new GregorianCalendar();
    c.set(Calendar.YEAR, year);
    c.set(Calendar.MONTH, Calendar.JANUARY);
    c.set(Calendar.DATE, 1);
    Calendar cal = (GregorianCalendar) c.clone();
    cal.add(Calendar.DATE, week * 7);
    return getLastDayOfWeek(cal.getTime());
}
### 类导入的包
java.util.Calendar
java.util.GregorianCalendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getFirstDayOfMonth的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某年某月的第一天
     *
     * @param year  目标年份
     * @param month 目标月份
     * @return
     */
public static Date getFirstDayOfMonth(int year, int month) {
    month = month - 1;
    Calendar c = Calendar.getInstance();
    c.set(Calendar.YEAR, year);
    c.set(Calendar.MONTH, month);
    int day = c.getActualMinimum(Calendar.DAY_OF_MONTH);
    c.set(Calendar.DAY_OF_MONTH, day);
    c.set(Calendar.HOUR_OF_DAY, 0);
    c.set(Calendar.MINUTE, 0);
    c.set(Calendar.SECOND, 0);
    c.set(Calendar.MILLISECOND, 0);
    return c.getTime();
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getLastDayOfMonth的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某年某月的最后一天
     *
     * @param year  目标年份
     * @param month 目标月份
     * @return
     */
public static Date getLastDayOfMonth(int year, int month) {
    month = month - 1;
    Calendar c = Calendar.getInstance();
    c.set(Calendar.YEAR, year);
    c.set(Calendar.MONTH, month);
    int day = c.getActualMaximum(Calendar.DAY_OF_MONTH);
    c.set(Calendar.DAY_OF_MONTH, day);
    c.set(Calendar.HOUR_OF_DAY, 23);
    c.set(Calendar.MINUTE, 59);
    c.set(Calendar.SECOND, 59);
    c.set(Calendar.MILLISECOND, 999);
    return c.getTime();
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDayWeekOfDate1的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取某个日期为星期几
     *
     * @param date
     * @return String "星期*"
     */
public static String getDayWeekOfDate1(Date date) {
    String[] weekDays = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
    if (w < 0) {
        w = 0;
    }
    return weekDays[w];
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getWeekValue的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据星期几返回数字类型
     *
     * @param date
     */
public static Integer getWeekValue(Date date) {
    String week = DateUtil.getDayWeekOfDate1(date);
    if ("星期日".equals(week)) {
        return 0;
    }
    if ("星期一".equals(week)) {
        return 1;
    }
    if ("星期二".equals(week)) {
        return 2;
    }
    if ("星期三".equals(week)) {
        return 3;
    }
    if ("星期四".equals(week)) {
        return 4;
    }
    if ("星期五".equals(week)) {
        return 5;
    }
    if ("星期六".equals(week)) {
        return 6;
    } else {
        return null;
    }
}
### 类导入的包
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDayWeekOfDate2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获得指定日期的星期几数
     *
     * @param date
     * @return int
     */
public static Integer getDayWeekOfDate2(Date date) {
    Calendar aCalendar = Calendar.getInstance();
    aCalendar.setTime(date);
    int weekDay = aCalendar.get(Calendar.DAY_OF_WEEK);
    return weekDay;
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为validateIsDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 验证字符串是否为日期
     * 验证格式:YYYYMMDD、YYYY_MM_DD、YYYYMMDDHHMISS、YYYYMMDD_HH_MI、YYYY_MM_DD_HH_MI、YYYYMMDDHHMISSSSS、YYYY_MM_DD_HH_MI_SS
     *
     * @param strTime
     * @return null时返回false;true为日期，false不为日期
     */
public static boolean validateIsDate(String strTime) {
    if (strTime == null || strTime.trim().length() <= 0) {
        return false;
    }
    Date date = null;
    List<String> list = new ArrayList<String>(0);
    list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);
    list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);
    list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);
    list.add(DATE_TIME_FORMAT_YYYYMMDD_HH_MI);
    list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISS);
    list.add(DATE_FORMAT_YYYY_MM_DD);
    list.add(DATE_FORMAT_YYYYMMDD);
    for (Iterator iter = list.iterator(); iter.hasNext(); ) {
        String format = (String) iter.next();
        if (strTime.indexOf("-") > 0 && format.indexOf("-") < 0) {
            continue;
        }
        if (strTime.indexOf("-") < 0 && format.indexOf("-") > 0) {
            continue;
        }
        if (strTime.length() > format.length()) {
            continue;
        }
        date = parseStrToDate(strTime.trim(), format);
        if (date != null) {
            break;
        }
    }
    if (date != null) {
        System.out.println("生成的日期:" + DateUtil.parseDateToStr(date, DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS, "--null--"));
        return true;
    }
    return false;
}
### 类导入的包
java.util.ArrayList
java.util.Date
java.util.Iterator
java.util.List
### 类级别的变量
/**
 * 日期格式，年份，例如：2004，2008
 */
public static final String DATE_FORMAT_YYYY = "yyyy";
/**
 * 日期格式，年份和月份，例如：200707，200808
 */
public static final String DATE_FORMAT_YYYYMM = "yyyyMM";
/**
 * 日期格式，年份和月份，例如：200707，2008-08
 */
public static final String DATE_FORMAT_YYYY_MM = "yyyy-MM";
/**
 * 日期格式，年月日，例如：20050630，20080808
 */
public static final String DATE_FORMAT_YYYYMMDD = "yyyyMMdd";
/**
 * 日期格式，年月日，用横杠分开，例如：2006-12-25，2008-08-08
 */
public static final String DATE_FORMAT_YYYY_MM_DD = "yyyy-MM-dd";
/**
 * 日期格式，年月日时分，例如：20001230 12:00，20080808 20:08
 */
public static final String DATE_TIME_FORMAT_YYYYMMDD_HH_MI = "yyyyMMdd HH:mm";
/**
 * 日期格式，年月日时分，例如：2000-12-30 12:00，2008-08-08 20:08
 */
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";
/**
 * 日期格式，年月日时分秒，例如：20001230120000，20080808200808
 */
public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISS = "yyyyMMddHHmmss";
/**
 * 日期格式，年月日时分秒，年月日用横杠分开，时分秒用冒号分开
 * 例如：2005-05-10 23：20：00，2008-08-08 20:08:08
 */
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";
/**
 * 日期格式，年月日时分秒毫秒，例如：20001230120000123，20080808200808456
 */
public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS = "yyyyMMddHHmmssSSS";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为formatHhMmSsOfDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将指定日期的时分秒格式为零
     *
     * @param date
     * @return
     */
public static Date formatHhMmSsOfDate(Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);
    return cal.getTime();
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为formatHhMmOfDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将指定日期的秒格式为零
     *
     * @param date
     * @return
     */
public static Date formatHhMmOfDate(Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);
    return cal.getTime();
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为addDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获得指定时间加减参数后的日期(不计算则输入0)
     *
     * @param date        指定日期
     * @param year        年数，可正可负
     * @param month       月数，可正可负
     * @param day         天数，可正可负
     * @param hour        小时数，可正可负
     * @param minute      分钟数，可正可负
     * @param second      秒数，可正可负
     * @param millisecond 毫秒数，可正可负
     * @return 计算后的日期
     */
public static Date addDate(Date date, int year, int month, int day, int hour, int minute, int second, int millisecond) {
    Calendar c = Calendar.getInstance();
    c.setTime(date);
    //加减年数
    c.add(Calendar.YEAR, year);
    //加减月数
    c.add(Calendar.MONTH, month);
    //加减天数
    c.add(Calendar.DATE, day);
    //加减小时数
    c.add(Calendar.HOUR, hour);
    //加减分钟数
    c.add(Calendar.MINUTE, minute);
    //加减秒
    c.add(Calendar.SECOND, second);
    //加减毫秒数
    c.add(Calendar.MILLISECOND, millisecond);
    return c.getTime();
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为compareIsSameMonth的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 判断二个时间是否为同年同月
     *
     * @param date1
     * @param date2
     * @return
     */
public static Boolean compareIsSameMonth(Date date1, Date date2) {
    boolean flag = false;
    int year1 = getYear(date1);
    int year2 = getYear(date2);
    if (year1 == year2) {
        int month1 = getMonth(date1);
        int month2 = getMonth(date2);
        if (month1 == month2) {
            flag = true;
        }
    }
    return flag;
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDistanceTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获得两个时间相差距离多少天多少小时多少分多少秒
     *
     * @param one 时间参数 1 格式：1990-01-01 12:00:00
     * @param two 时间参数 2 格式：2009-01-01 12:00:00
     * @return long[] 返回值为：{天, 时, 分, 秒}
     */
public static long[] getDistanceTime(Date one, Date two) {
    long day = 0;
    long hour = 0;
    long min = 0;
    long sec = 0;
    try {
        long time1 = one.getTime();
        long time2 = two.getTime();
        long diff;
        if (time1 < time2) {
            diff = time2 - time1;
        } else {
            diff = time1 - time2;
        }
        day = diff / (24 * 60 * 60 * 1000);
        hour = (diff / (60 * 60 * 1000) - day * 24);
        min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
        sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
    } catch (Exception e) {
        e.printStackTrace();
    }
    long[] times = { day, hour, min, sec };
    return times;
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDistanceTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 两个时间相差距离多少天多少小时多少分多少秒
     *
     * @param str1 时间参数 1 格式：1990-01-01 12:00:00
     * @param str2 时间参数 2 格式：2009-01-01 12:00:00
     * @return String 返回值为：{天, 时, 分, 秒}
     */
public static long[] getDistanceTime(String str1, String str2) {
    DateFormat df = new SimpleDateFormat(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);
    Date one;
    Date two;
    long day = 0;
    long hour = 0;
    long min = 0;
    long sec = 0;
    try {
        one = df.parse(str1);
        two = df.parse(str2);
        long time1 = one.getTime();
        long time2 = two.getTime();
        long diff;
        if (time1 < time2) {
            diff = time2 - time1;
        } else {
            diff = time1 - time2;
        }
        day = diff / (24 * 60 * 60 * 1000);
        hour = (diff / (60 * 60 * 1000) - day * 24);
        min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
        sec = (diff / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    long[] times = { day, hour, min, sec };
    return times;
}
### 类导入的包
java.text.DateFormat
java.text.ParseException
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量
/**
 * 日期格式，年月日时分，例如：2000-12-30 12:00，2008-08-08 20:08
 */
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";
/**
 * 日期格式，年月日时分秒，年月日用横杠分开，时分秒用冒号分开
 * 例如：2005-05-10 23：20：00，2008-08-08 20:08:08
 */
public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDistanceDays的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 两个时间之间相差距离多少天
     *
     * @param str1 时间参数 1：
     * @param str2 时间参数 2：
     * @return 相差天数
     */
public static Long getDistanceDays(String str1, String str2) throws Exception {
    DateFormat df = new SimpleDateFormat(DATE_FORMAT_YYYY_MM_DD);
    Date one;
    Date two;
    long days = 0;
    try {
        one = df.parse(str1);
        two = df.parse(str2);
        long time1 = one.getTime();
        long time2 = two.getTime();
        long diff;
        if (time1 < time2) {
            diff = time2 - time1;
        } else {
            diff = time1 - time2;
        }
        days = diff / (1000 * 60 * 60 * 24);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return days;
}
### 类导入的包
java.text.DateFormat
java.text.ParseException
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量
/**
 * 日期格式，年份，例如：2004，2008
 */
public static final String DATE_FORMAT_YYYY = "yyyy";
/**
 * 日期格式，年份和月份，例如：200707，2008-08
 */
public static final String DATE_FORMAT_YYYY_MM = "yyyy-MM";
/**
 * 日期格式，年月日，用横杠分开，例如：2006-12-25，2008-08-08
 */
public static final String DATE_FORMAT_YYYY_MM_DD = "yyyy-MM-dd";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDayBeginTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取指定时间的那天 00:00:00.000 的时间
     *
     * @param date
     * @return
     */
public static Date getDayBeginTime(final Date date) {
    Calendar c = Calendar.getInstance();
    c.setTime(date);
    c.set(Calendar.HOUR_OF_DAY, 0);
    c.set(Calendar.MINUTE, 0);
    c.set(Calendar.SECOND, 0);
    c.set(Calendar.MILLISECOND, 0);
    return c.getTime();
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDayEndTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取指定时间的那天 23:59:59.999 的时间
     *
     * @param date
     * @return
     */
public static Date getDayEndTime(final Date date) {
    Calendar c = Calendar.getInstance();
    c.setTime(date);
    c.set(Calendar.HOUR_OF_DAY, 23);
    c.set(Calendar.MINUTE, 59);
    c.set(Calendar.SECOND, 59);
    c.set(Calendar.MILLISECOND, 999);
    return c.getTime();
}
### 类导入的包
java.util.Calendar
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为isValidDate的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 日期格式校验
     *
     * @param DateStr 日期字符串
     * @param pattern 指定校验格式
     * @return
     */
public static boolean isValidDate(String DateStr, String pattern) {
    boolean convertSuccess = true;
    SimpleDateFormat format = new SimpleDateFormat(pattern);
    try {
        // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
        format.setLenient(false);
        format.parse(DateStr);
    } catch (ParseException e) {
        // 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
        convertSuccess = false;
    }
    return convertSuccess;
}
### 类导入的包
java.text.DateFormat
java.text.ParseException
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为valiDateFormat的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验日期格式是否为yyyy-MM-dd
     *
     * @param timeStr 正确返回true
     * @return
     */
public static boolean valiDateFormat(String timeStr) {
    String format = "((19|20)[0-9]{2})-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])";
    Pattern pattern = Pattern.compile(format);
    Matcher matcher = pattern.matcher(timeStr);
    if (matcher.matches()) {
        pattern = Pattern.compile("(\\d{4})-(\\d+)-(\\d+).*");
        matcher = pattern.matcher(timeStr);
        if (matcher.matches()) {
            int y = Integer.valueOf(matcher.group(1));
            int m = Integer.valueOf(matcher.group(2));
            int d = Integer.valueOf(matcher.group(3));
            if (d > 28) {
                Calendar c = Calendar.getInstance();
                c.set(y, m - 1, 1);
                int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
                return (lastDay >= d);
            }
        }
        return true;
    }
    return false;
}
### 类导入的包
java.util.Calendar
java.util.regex.Matcher
java.util.regex.Pattern
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DateUtil中有一个名为getDiffTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 计算两个时间相差秒数
     *
     * @param endDate
     * @param startDate
     * @return
     * @throws ParseException
     */
public static long getDiffTime(Date endDate, Date startDate) throws ParseException {
    // 相差的毫秒值
    Long milliseconds = endDate.getTime() - startDate.getTime();
    // 一天的毫秒数
    long nd = 1000 * 24 * 60 * 60;
    // 一小时的毫秒数
    long nh = 1000 * 60 * 60;
    // 一分钟的毫秒数
    long nm = 1000 * 60;
    // 一秒钟的毫秒数
    long ns = 1000;
    //        long day = milliseconds / nd; // 计算相差多少天
    //        long hour = milliseconds % nd / nh; // 计算相差剩余多少小时
    //        long min = milliseconds % nd % nh / nm; // 计算相差剩余多少分钟
    // 计算相差剩余多少秒
    long sec = milliseconds % nd % nh % nm / ns;
    return sec;
}
### 类导入的包
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DirectorySizeUtils中有一个名为humanReadableByteCount的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String humanReadableByteCount(long bytes) {
    if (bytes < 0) {
        return "bytes: " + bytes;
    }
    int unit = 1024;
    if (bytes < unit) {
        return bytes + " bytes";
    }
    int exp = (int) (Math.log(bytes) / Math.log(unit));
    String[] pre = new String[] { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
    return String.format("%.1f %s", bytes / Math.pow(unit, exp), pre[exp]);
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DirectorySizeUtils中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    Path directoryPath = Paths.get("F:\\share\\Langchain-Chatchat");
    try {
        long size = getDirectorySizeParallel(directoryPath);
        System.out.printf("The directory '%s' takes up %d bytes.%n", directoryPath, size);
        // 转换为人类可读的格式（例如KB, MB, GB）
        System.out.println(humanReadableByteCount(size));
    } catch (Exception e) {
        e.printStackTrace();
    }
}
### 类导入的包
java.nio.file.Path
java.nio.file.Paths
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DirectoryUtils中有一个名为createDirectory的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 创建一个目录，由给定的多个目录名（子目录）拼接而成。
     * 如果提供的目录名为空或者目录创建失败，则返回null。
     *
     * @param subDirs 可变数量的子目录名(项目ID+用户ID+业务类型+业务表主键)
     * @return 创建的目录（如果成功），否则返回null
     */
public static File createDirectory(String... subDirs) {
    if (StringUtils.isBlank(basePath)) {
        // 父目录为空，返回null
        return null;
    }
    Path fullPath = Paths.get(basePath);
    // 遍历子目录
    for (String subDir : subDirs) {
        if (StringUtils.isBlank(subDir)) {
            // 子目录名为空，返回null
            return null;
        }
        fullPath = fullPath.resolve(subDir);
    }
    // 转换为File对象（如果需要）
    File dir = fullPath.toFile();
    if (!dir.exists()) {
        // 尝试创建目录
        if (!dir.mkdirs()) {
            // 创建失败，返回null或可以选择抛出异常
            return null;
        }
    }
    // 创建成功，返回目录
    return dir;
}
### 类导入的包
org.apache.commons.lang3.StringUtils
java.io.File
java.nio.file.Path
java.nio.file.Paths
### 类级别的变量
private static String basePath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DirectoryUtils中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    // 示例用法
    File directory = createDirectory("D:\\cephfs\\temp", "subDir1", "subDir2", "subDir3");
    if (directory != null) {
        System.out.println("创建的目录：" + directory.getAbsolutePath());
    } else {
        System.out.println("目录创建失败");
    }
}
### 类导入的包
java.io.File
java.nio.file.Path
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DockerUtils中有一个名为pushImage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 推送镜像
     *
     * @param dockerClient
     * @param imageName
     * @return
     * @throws InterruptedException
     */
public static Boolean pushImage(DockerClient dockerClient, String imageName) throws InterruptedException {
    final Boolean[] result = { true };
    ResultCallback.Adapter<PushResponseItem> callBack = new ResultCallback.Adapter<PushResponseItem>() {

        @Override
        public void onNext(PushResponseItem pushResponseItem) {
            if (pushResponseItem != null) {
                ResponseItem.ErrorDetail errorDetail = pushResponseItem.getErrorDetail();
                if (errorDetail != null) {
                    result[0] = false;
                    log.error(errorDetail.getMessage(), errorDetail);
                }
            }
            super.onNext(pushResponseItem);
        }
    };
    dockerClient.pushImageCmd(imageName).exec(callBack).awaitCompletion();
    return result[0];
}
### 类导入的包
com.github.dockerjava.api.async.ResultCallback
com.github.dockerjava.api.model.Image
com.github.dockerjava.api.model.PushResponseItem
com.github.dockerjava.api.model.ResponseItem
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DockerUtils中有一个名为buildImage的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//    }
public static String buildImage(DockerClient dockerClient, File dockerFile) {
    BuildImageCmd buildImageCmd = dockerClient.buildImageCmd().withDockerfile(dockerFile).withNetworkMode("host");
    BuildImageResultCallback buildImageResultCallback = new BuildImageResultCallback() {

        @Override
        public void onNext(BuildResponseItem item) {
            super.onNext(item);
        }
    };
    return buildImageCmd.exec(buildImageResultCallback).awaitImageId();
}
### 类导入的包
com.github.dockerjava.api.async.ResultCallback
com.github.dockerjava.api.command.BuildImageCmd
com.github.dockerjava.api.command.BuildImageResultCallback
com.github.dockerjava.api.model.BuildResponseItem
com.github.dockerjava.api.model.Image
com.github.dockerjava.api.model.ResponseItem
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类DownloadFileUtil中有一个名为download的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 下载模板
     *
     * @param filePath 下载路径
     * @param filePath 文件上级目录
     * @param fileName 文件名
     * @param newName  下载的展示文件名
     * @return 响应
     */
public static ResponseEntity<InputStreamResource> download(String route, String filePath, String fileName, String newName) {
    String path;
    ResponseEntity<InputStreamResource> response = null;
    InputStream inputStream = null;
    try {
        if (StringUtils.isNotBlank(filePath)) {
            path = route + filePath + SEPARATOR + fileName;
        } else {
            path = route + fileName;
        }
        ClassPathResource classPathResource = new ClassPathResource(path);
        inputStream = classPathResource.getInputStream();
        HttpHeaders headers = new HttpHeaders();
        headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
        headers.add("Content-Disposition", "attachment; filename=" + new String(newName.getBytes("gbk"), "iso8859-1") + ".zip");
        headers.add("Pragma", "no-cache");
        headers.add("Expires", "0");
        response = ResponseEntity.ok().headers(headers).contentType(MediaType.parseMediaType("application/octet-stream")).body(new InputStreamResource(inputStream));
    } catch (FileNotFoundException e1) {
        log.error("找不到指定的文件", e1);
    } catch (Exception e) {
        log.error("获取不到文件流", e);
    } finally {
        IOUtils.closeQuietly(inputStream);
    }
    return response;
}
### 类导入的包
org.apache.commons.io.IOUtils
org.apache.commons.lang3.StringUtils
org.springframework.core.io.ClassPathResource
org.springframework.core.io.InputStreamResource
org.springframework.http.HttpHeaders
org.springframework.http.MediaType
org.springframework.http.ResponseEntity
java.io.File
java.io.FileNotFoundException
java.io.InputStream
### 类级别的变量
public static final String SEPARATOR = File.separator;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为getMultipartFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将File转成MultipartFile对象
     *
     * @param file
     * @return
     */
public static MultipartFile getMultipartFile(File file) {
    FileItem item = new DiskFileItemFactory().createItem("file", MediaType.MULTIPART_FORM_DATA_VALUE, true, file.getName());
    try (InputStream input = new FileInputStream(file);
        OutputStream os = item.getOutputStream()) {
        // 流转移
        IOUtils.copy(input, os);
    } catch (Exception e) {
        throw new IllegalArgumentException("Invalid file: " + e, e);
    }
    return new CommonsMultipartFile(item);
}
### 类导入的包
org.apache.commons.compress.utils.IOUtils
org.apache.commons.fileupload.FileItem
org.apache.commons.fileupload.FileItemFactory
org.apache.commons.fileupload.disk.DiskFileItemFactory
org.springframework.http.MediaType
org.springframework.web.multipart.MultipartFile
org.springframework.web.multipart.commons.CommonsMultipartFile
java.io.File
java.io.FileInputStream
java.io.InputStream
java.io.OutputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为readStreamObject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 下载文件流
     *
     * @param filePath
     * @return
     * @throws Exception
     */
public static InputStream readStreamObject(String filePath) throws Exception {
    if (StringUtils.isBlank(filePath)) {
        throw new Exception("文件路径不能为空");
    }
    InputStream fis;
    try {
        // 将文件写入输入流
        FileInputStream fileInputStream = new FileInputStream(FileUtils.getFile(filePath));
        fis = new BufferedInputStream(fileInputStream);
    } catch (Exception e) {
        log.info("下载文件流异常", e);
        throw new Exception("下载文件流异常");
    }
    return fis;
}
### 类导入的包
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
java.io.BufferedInputStream
java.io.File
java.io.FileInputStream
java.io.InputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为deleteFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除文件路径
     *
     * @param filePath
     * @return
     */
public static boolean deleteFile(String filePath) {
    if (StringUtils.isBlank(filePath)) {
        log.info("filePath为空");
        return false;
    }
    try {
        File file = FileUtils.getFile(filePath);
        if (file.exists()) {
            file.delete();
        }
    } catch (Exception e) {
        log.info("刪除异常", e);
        return false;
    }
    return true;
}
### 类导入的包
org.apache.commons.io.FileUtils
org.apache.commons.lang3.StringUtils
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为deleteFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除目录及目录下所有文件
     *
     * @param filePath
     */
public static void deleteFile(File filePath) {
    //判断路径是否存在
    if (filePath.exists()) {
        //判断是否是目录
        if (filePath.isDirectory()) {
            //将目录逐层拆分成数组元素
            File[] file = filePath.listFiles();
            for (File f : file) {
                //递归调用,由最底层往上逐层删除
                deleteFile(f);
            }
        }
        //如果是文件，直接删除
        filePath.delete();
    }
}
### 类导入的包
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为inputStream2Base64的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将inputstream转为Base64
     *
     * @param is
     * @return
     * @throws Exception
     */
public static String inputStream2Base64(InputStream is) throws Exception {
    byte[] data;
    try {
        ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
        byte[] buff = new byte[100];
        int rc;
        while ((rc = is.read(buff, 0, 100)) > 0) {
            swapStream.write(buff, 0, rc);
        }
        data = swapStream.toByteArray();
    } catch (IOException e) {
        log.info("inputStream2Base64异常", e);
        throw new Exception("inputStream2Base64异常");
    } finally {
        if (is != null) {
            try {
                is.close();
            } catch (IOException e) {
                throw new Exception("输入流关闭异常");
            }
        }
    }
    return Base64.getEncoder().encodeToString(data);
}
### 类导入的包
java.io.ByteArrayOutputStream
java.io.IOException
java.io.OutputStream
java.util.Base64
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为bufferedImageToInputStream的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将BufferedImage转换为InputStream
     *
     * @param image
     * @return
     */
public static InputStream bufferedImageToInputStream(BufferedImage image) throws Exception {
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    InputStream input;
    try {
        ImageIO.write(image, "jpeg", os);
        input = new ByteArrayInputStream(os.toByteArray());
    } catch (IOException e) {
        log.info("bufferedImageToInputStream转换异常:", e);
        throw new Exception("bufferedImageToInputStream异常");
    }
    return input;
}
### 类导入的包
javax.imageio.ImageIO
java.io.ByteArrayInputStream
java.io.ByteArrayOutputStream
java.io.IOException
java.io.InputStream
java.io.OutputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为getFileStream2Base64的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取文件输入流并转化为Base64
     *
     * @param filePath
     * @return
     * @throws Exception
     */
public static String getFileStream2Base64(String filePath) throws Exception {
    String base64;
    try {
        //从ceph通过流形式读取到文件并转为Base64
        InputStream inputStream = readStreamObject(filePath);
        base64 = inputStream2Base64(inputStream);
        //log.info("base64:" + base64);
    } catch (Exception e) {
        log.info("fileStream2Base64转换异常:", e);
        throw new Exception("fileStream2Base64转换异常");
    }
    return base64;
}
### 类导入的包
java.io.InputStream
java.util.Base64
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为createFileItem的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * FileItem类对象创建
     *
     * @param inputStream inputStream
     * @param fileName    fileName
     * @return FileItem
     */
public static FileItem createFileItem(InputStream inputStream, String fileName) {
    FileItemFactory factory = new DiskFileItemFactory(16, null);
    String textFieldName = "file";
    FileItem item = factory.createItem(textFieldName, MediaType.MULTIPART_FORM_DATA_VALUE, true, fileName);
    int bytesRead = 0;
    byte[] buffer = new byte[8192];
    OutputStream os = null;
    //使用输出流输出输入流的字节
    try {
        os = item.getOutputStream();
        while ((bytesRead = inputStream.read(buffer, 0, 8192)) != -1) {
            os.write(buffer, 0, bytesRead);
        }
        inputStream.close();
    } catch (IOException e) {
        log.error("Stream copy exception", e);
        throw new IllegalArgumentException("文件上传失败");
    } finally {
        if (os != null) {
            try {
                os.close();
            } catch (IOException e) {
                log.error("Stream close exception", e);
            }
        }
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                log.error("Stream close exception", e);
            }
        }
    }
    return item;
}
### 类导入的包
org.apache.commons.fileupload.FileItem
org.apache.commons.fileupload.FileItemFactory
org.apache.commons.fileupload.disk.DiskFileItemFactory
org.springframework.http.MediaType
java.io.File
java.io.IOException
java.io.OutputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为createDir的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 创建目录
     *
     * @param filePath
     */
public static void createDir(String filePath) throws IOException {
    File file = FileUtils.getFile(filePath);
    if (!file.exists() && !file.isDirectory()) {
        file.mkdirs();
        //设置可执行权限
        file.setExecutable(true, false);
        //设置可读权限
        file.setReadable(true, false);
        //设置可写权限
        file.setWritable(true, false);
    }
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为createFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 生成.txt格式文件
     *
     * @param str      字符串
     * @param filePath 生成路径
     * @return
     */
public static boolean createFile(String str, String filePath) {
    // 标记文件生成是否成功
    boolean flag = true;
    FileOutputStream fos = null;
    try {
        // 保证创建一个新文件
        File file = FileUtils.getFile(filePath);
        // 如果父目录不存在，创建父目录
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        // 如果已存在,删除旧文件
        if (file.exists()) {
            file.delete();
        }
        file.createNewFile();
        // 将格式化后的字符串写入文件
        fos = new FileOutputStream(file);
        Writer write = new OutputStreamWriter(fos, "UTF-8");
        write.write(str);
        write.flush();
        write.close();
    } catch (Exception e) {
        log.info("生成文件异常", e);
        flag = false;
    } finally {
        try {
            if (fos != null) {
                fos.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 返回是否成功的标记
    return flag;
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
java.io.FileOutputStream
java.io.IOException
java.io.OutputStream
java.io.OutputStreamWriter
java.io.Writer
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为createCSVFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static boolean createCSVFile(List<String[]> data, String filePath) {
    // 标记文件生成是否成功
    boolean flag = true;
    try {
        // 保证创建一个新文件
        File file = FileUtils.getFile(filePath);
        // 如果父目录不存在，创建父目录
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        // 如果已存在,删除旧文件
        if (file.exists()) {
            file.delete();
        }
        file.createNewFile();
    } catch (Exception e) {
        log.info("创建文件目录异常", e);
        flag = false;
    }
    try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath));
        CSVPrinter csvPrinter = new CSVPrinter(writer, CSVFormat.DEFAULT.withHeader(data.get(0)))) {
        for (String[] rowData : data.subList(1, data.size())) {
            csvPrinter.printRecord(rowData);
        }
        // 确保写入所有数据到文件
        csvPrinter.flush();
    } catch (IOException e) {
        log.info("生成文件异常", e);
        flag = false;
    }
    // 返回是否成功的标记
    return flag;
}
### 类导入的包
org.apache.commons.csv.CSVFormat
org.apache.commons.csv.CSVPrinter
org.apache.commons.io.FileUtils
java.io.BufferedWriter
java.io.File
java.io.FileWriter
java.io.IOException
java.io.Writer
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为readCSV的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static List<CSVRecord> readCSV(String filePath) {
    try (FileReader reader = new FileReader(filePath);
        CSVParser csvParser = new CSVParser(reader, CSVFormat.DEFAULT)) {
        return csvParser.getRecords();
    } catch (IOException e) {
        log.info("读取csv文件异常", e);
        return null;
    }
}
### 类导入的包
org.apache.commons.csv.CSVFormat
org.apache.commons.csv.CSVParser
java.io.File
java.io.FileReader
java.io.IOException
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为readTxt的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 读取指定长度文件内容
     *
     * @param filePath
     */
public static String readTxt(String filePath) {
    StringBuilder sb = new StringBuilder();
    String shortText = null;
    FileReader fr = null;
    try {
        fr = new FileReader(FileUtils.getFile(filePath));
        int content = 0;
        int i = 0;
        while ((content = fr.read()) != -1) {
            if (i <= 150) {
                sb.append((char) content);
            } else {
                break;
            }
            i++;
        }
        fr.close();
        shortText = new String(sb);
    } catch (Exception e) {
        log.info("读取txt异常", e);
    } finally {
        try {
            if (fr != null) {
                fr.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return shortText;
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
java.io.FileReader
java.io.IOException
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为fileSliceIsBadAndSort的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 判断所有分片是否完整
     *
     * @param slicePath
     * @return
     */
public static boolean fileSliceIsBadAndSort(String slicePath) {
    try {
        File[] files = FileUtils.getFile(slicePath).listFiles();
        List<String> filesAll = new ArrayList<>();
        for (File file : files) {
            filesAll.add(file.getName());
        }
        if (filesAll.size() < 1) {
            //分片缺少,删除全部分片文件,从新上传
            File filePath = FileUtils.getFile(slicePath);
            if (filePath.exists()) {
                FileUtil.deleteFile(filePath);
            }
            return false;
        }
        //从小到大文件进行按照序号排序
        List<String> collect = filesAll.stream().sorted((a, b) -> fileId(a) - fileId(b)).collect(Collectors.toList());
        //判断文件是否损坏,将文件排序后,进行前后序号相差大于1那么就代表少分片了
        for (int i = 0; i < collect.size() - 1; i++) {
            //检测分片的连续度
            if (fileId(collect.get(i)) - fileId(collect.get(i + 1)) != -1) {
                //分片损坏 删除全部分片文件 ,从新上传
                File filePath = FileUtils.getFile(slicePath);
                if (filePath.exists()) {
                    FileUtil.deleteFile(filePath);
                }
                return false;
            }
        }
    } catch (Exception e) {
        log.info("分片校验异常", e);
        //分片损坏 删除全部分片文件 ,从新上传
        File filePath = FileUtils.getFile(slicePath);
        if (filePath.exists()) {
            FileUtil.deleteFile(filePath);
        }
        return false;
    }
    return true;
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
java.util.ArrayList
java.util.List
java.util.stream.Collectors
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为fileMerge的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 合并分片
     *
     * @param chunkFolder 需合并分片所在文件夹
     * @param mergeFile   合并后所在文件夹
     * @return
     */
public static boolean fileMerge(File chunkFolder, File mergeFile) {
    FileChannel fosChannel = null;
    FileInputStream fis = null;
    try {
        // 如果该文件存在则先删除
        if (mergeFile.exists()) {
            mergeFile.delete();
        }
        // 创建合并后的文件
        mergeFile.createNewFile();
        // 获取分块列表
        File[] fileArray = chunkFolder.listFiles();
        // 把文件转成集合并排序
        ArrayList<File> fileList = new ArrayList<>(Arrays.asList(fileArray));
        // 从小到大进行排序
        Collections.sort(fileList, (o1, o2) -> {
            if (Integer.parseInt(o1.getName().trim()) < Integer.parseInt(o2.getName().trim())) {
                return -1;
            }
            return 1;
        });
        // 合并文件
        fosChannel = new FileOutputStream(mergeFile).getChannel();
        for (File chunkFile : fileList) {
            fis = new FileInputStream(chunkFile);
            FileChannel fisChannel = fis.getChannel();
            fisChannel.transferTo(0, fisChannel.size(), fosChannel);
            fisChannel.close();
        }
    } catch (Exception e) {
        log.info("分片合并异常", e);
        return false;
    } finally {
        try {
            if (fis != null) {
                fis.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (fosChannel != null) {
                fosChannel.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return true;
}
### 类导入的包
java.io.File
java.io.FileInputStream
java.io.FileOutputStream
java.io.IOException
java.io.InputStream
java.io.OutputStream
java.nio.channels.FileChannel
java.util.ArrayList
java.util.Arrays
java.util.Collections
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为readCsvLastLine的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 解析CSV文件读取最后一行
     *
     * @param file
     * @return
     */
public static Map<String, String> readCsvLastLine(File file) {
    Map<String, String> maps = new HashMap<>();
    String lastLine = "";
    try (ReversedLinesFileReader reversedLinesReader = new ReversedLinesFileReader(file)) {
        lastLine = reversedLinesReader.readLine();
        if (StringUtils.isNotBlank(lastLine)) {
            String[] info = lastLine.split(",");
            String precision = info[4].trim();
            String recall = info[5].trim();
            if (StringUtils.isNotBlank(precision)) {
                precision = getPercent(Double.parseDouble(precision), 2);
            }
            if (StringUtils.isNotBlank(recall)) {
                recall = getPercent(Double.parseDouble(recall), 2);
            }
            maps.put("precision", precision);
            maps.put("recall", recall);
        }
    } catch (Exception e) {
        log.info("解析CSV文件异常: {}", e);
    }
    return maps;
}
### 类导入的包
org.apache.commons.io.input.ReversedLinesFileReader
org.apache.commons.lang3.StringUtils
java.io.File
java.io.FileReader
java.util.HashMap
java.util.Map
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为deleteTempFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除指定后缀名的临时文件
     *
     * @param path 指定目录
     */
public static void deleteTempFile(String path) {
    String suffixName = "zip_tmp";
    File file = FileUtils.getFile(path);
    File temp;
    File[] filelist = file.listFiles();
    for (int i = 0; i < filelist.length; i++) {
        temp = filelist[i];
        if (temp.getName().endsWith(suffixName)) {
            temp.delete();
        }
    }
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为getFileNames的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 得到文件名称
     *
     * @param path
     * @return
     */
public List<String> getFileNames(String path) {
    File file = FileUtils.getFile(path);
    if (!file.exists()) {
        return null;
    }
    List<String> fileNames = new ArrayList<>();
    return getFileNames(file, fileNames);
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
java.util.ArrayList
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为getFileNames的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 得到文件名称
     *
     * @param file
     * @param fileNames
     * @return
     */
public List<String> getFileNames(File file, List<String> fileNames) {
    File[] files = file.listFiles();
    for (File f : files) {
        if (f.isDirectory()) {
            getFileNames(f, fileNames);
        } else {
            String ext = FilenameUtils.getExtension(f.getName());
            if ("txt".equalsIgnoreCase(ext)) {
                fileNames.add(f.getAbsolutePath());
            } else if ("xlsx".equalsIgnoreCase(ext)) {
                fileNames.add(f.getAbsolutePath());
            } else if ("csv".equalsIgnoreCase(ext)) {
                fileNames.add(f.getAbsolutePath());
            } else if ("doc".equalsIgnoreCase(ext)) {
                fileNames.add(f.getAbsolutePath());
            } else if ("docx".equalsIgnoreCase(ext)) {
                fileNames.add(f.getAbsolutePath());
            }
        }
    }
    return fileNames;
}
### 类导入的包
org.apache.commons.io.FilenameUtils
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为allowFileType的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Boolean allowFileType(String type) {
    String documents = "txt";
    String music = "mp3 wav wma mpa ram ra aac aif m4a";
    String video = "avi mpg mpe mpeg asf wmv mov qt rm mp4 flv m4v webm ogv ogg";
    String image = "jpg png jpeg";
    if (image.contains(type) || //                || video.contains(type)
    //                || music.contains(type)
    documents.contains(type)) {
        return true;
    }
    return false;
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为isValidImageExtension的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验图片后缀名是否为jpg, png, 或 jpeg中的一种。
     *
     * @param imageName 图片文件名（包含后缀）
     * @return 如果是jpg, png, 或 jpeg类型返回true，否则返回false
     */
public static boolean isValidImageExtension(String imageName) {
    if (imageName == null || imageName.isEmpty()) {
        // 如果图片名为空或空字符串，直接返回false
        return false;
    }
    // 获取文件扩展名（去掉前面的点）
    String extension = "";
    int dotIndex = imageName.lastIndexOf('.');
    if (dotIndex > 0 && dotIndex < imageName.length() - 1) {
        extension = imageName.substring(dotIndex + 1).toLowerCase();
    }
    // 校验扩展名是否为jpg, png, 或 jpeg
    return "jpg".equalsIgnoreCase(extension) || "png".equalsIgnoreCase(extension) || "jpeg".equalsIgnoreCase(extension);
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为isValidVideoExtension的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验图片后缀名是否为mp4中的一种。
     *
     * @param imageName 视频文件名（包含后缀）
     * @return 如果是mp4类型返回true，否则返回false
     */
public static boolean isValidVideoExtension(String imageName) {
    if (imageName == null || imageName.isEmpty()) {
        // 如果图片名为空或空字符串，直接返回false
        return false;
    }
    // 获取文件扩展名（去掉前面的点）
    String extension = "";
    int dotIndex = imageName.lastIndexOf('.');
    if (dotIndex > 0 && dotIndex < imageName.length() - 1) {
        extension = imageName.substring(dotIndex + 1).toLowerCase();
    }
    // 校验扩展名是否为mp4
    return "mp4".equalsIgnoreCase(extension);
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为isValidTextFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验文件名是否为txt类型。
     *
     * @param fileName 文件名（包含后缀）
     * @return 如果是txt类型返回true，否则返回false
     */
public static boolean isValidTextFile(String fileName) {
    if (fileName == null || fileName.isEmpty()) {
        // 如果文件名为空或空字符串，直接返回false
        return false;
    }
    // 获取文件扩展名（去掉前面的点）
    int dotIndex = fileName.lastIndexOf('.');
    if (dotIndex <= 0 || dotIndex == fileName.length() - 1) {
        // 如果没有找到点或者点在文件名的末尾，返回false
        return false;
    }
    String extension = fileName.substring(dotIndex + 1).toLowerCase();
    // 校验扩展名是否为txt
    return "txt".equalsIgnoreCase(extension);
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为isValidZipFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验文件名是否为zip压缩包类型。
     *
     * @param fileName 文件名（包含后缀）
     * @return 如果是zip压缩包类型返回true，否则返回false
     */
public static boolean isValidZipFile(String fileName) {
    if (fileName == null || fileName.isEmpty()) {
        // 如果文件名为空或空字符串，直接返回false
        return false;
    }
    // 获取文件扩展名（去掉前面的点）
    int dotIndex = fileName.lastIndexOf('.');
    if (dotIndex <= 0 || dotIndex == fileName.length() - 1) {
        // 如果没有找到点或者点在文件名的末尾，返回false
        return false;
    }
    String extension = fileName.substring(dotIndex + 1).toLowerCase();
    // 校验扩展名是否为zip
    return "zip".equalsIgnoreCase(extension);
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为validateZipFileContainsDisallowedFileTypes的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验ZIP包中的文件是否包含不允许的文件类型。
     *
     * @param zipFilePath          ZIP文件的路径
     * @param disallowedExtensions 不允许的文件扩展名列表
     * @return 如果ZIP包中不包含不允许的文件类型，则返回true；否则返回false
     * @throws IOException 如果读取ZIP文件时发生错误
     */
public static boolean validateZipFileContainsDisallowedFileTypes(String zipFilePath, List<String> disallowedExtensions) {
    try (FileInputStream fis = new FileInputStream(zipFilePath);
        ZipInputStream zis = new ZipInputStream(fis)) {
        // 尝试获取第一个ZIP条目
        ZipEntry zipEntry = zis.getNextEntry();
        // 如果zipEntry为null，说明ZIP文件是空的
        if (zipEntry == null) {
            log.info("ZIP包是空的");
            return false;
        }
        // 关闭当前ZIP条目以准备读取下一个条目（因为我们已经检查了第一个条目）
        zis.closeEntry();
        while ((zipEntry = zis.getNextEntry()) != null) {
            String fileName = zipEntry.getName();
            // 检查是否是文件（而不是文件夹）
            if (!zipEntry.isDirectory()) {
                // 获取文件扩展名
                String extension = getFileExtension(fileName);
                // 如果扩展名为空（即没有扩展名），则跳过当前文件，不进行校验
                if (extension == null) {
                    // 跳过当前循环迭代，继续下一个ZIP条目
                    continue;
                }
                // 如果扩展名在不允许的列表中，返回false
                if (disallowedExtensions.contains(extension.toLowerCase())) {
                    // 关闭当前ZIP条目以准备读取下一个条目
                    zis.closeEntry();
                    return false;
                }
            }
            // 关闭当前ZIP条目以准备读取下一个条目
            zis.closeEntry();
        }
    } catch (IOException e) {
        log.info("压缩包校验异常: {}", e);
        return false;
    }
    // 如果没有发现不允许的文件类型，返回true
    return true;
}
### 类导入的包
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
java.util.zip.ZipEntry
java.util.zip.ZipInputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为validateZipFileContainsOnlyAllowedTypes的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验ZIP包是否只包含允许的文件类型，并且至少包含一个允许的文件。
     * 如果ZIP包为空或没有包含允许的文件类型，则返回false。
     *
     * @param zipFilePath       ZIP文件的路径
     * @param allowedExtensions 允许的扩展名列表
     * @return 如果ZIP包只包含允许的文件类型且至少有一个允许的文件，则返回true；否则返回false
     */
public static boolean validateZipFileContainsOnlyAllowedTypes(String zipFilePath, List<String> allowedExtensions) {
    try (FileInputStream fis = new FileInputStream(zipFilePath);
        ZipInputStream zis = new ZipInputStream(fis)) {
        // 尝试获取第一个ZIP条目
        ZipEntry zipEntry = zis.getNextEntry();
        // 如果zipEntry为null，说明ZIP文件是空的
        if (zipEntry == null) {
            log.info("ZIP包是空的");
            return false;
        }
        // 关闭当前ZIP条目以准备读取下一个条目（因为我们已经检查了第一个条目）
        zis.closeEntry();
        // 标记是否找到了至少一个允许的文件
        boolean foundAllowedFile = false;
        while ((zipEntry = zis.getNextEntry()) != null) {
            String fileName = zipEntry.getName();
            // 如果是目录，跳过并继续处理下一个条目
            if (zipEntry.isDirectory()) {
                continue;
            }
            // 获取文件扩展名
            String extension = getFileExtension(fileName);
            // 如果扩展名为空（即没有扩展名），则跳过当前文件，不进行校验
            if (extension == null) {
                continue;
            }
            // 如果扩展名在允许的列表中，标记已找到允许的文件
            if (allowedExtensions.contains(extension.toLowerCase())) {
                foundAllowedFile = true;
            } else {
                // 如果发现不允许的文件类型，则直接返回false
                zis.closeEntry();
                return false;
            }
            // 关闭当前ZIP条目以准备读取下一个条目
            zis.closeEntry();
        }
        // 检查是否找到了至少一个允许的文件
        return foundAllowedFile;
    } catch (IOException e) {
        log.info("压缩包校验异常: {}", e);
        return false;
    }
}
### 类导入的包
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
java.util.zip.ZipEntry
java.util.zip.ZipInputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为validateTarFileContainsDisallowedFileTypes的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 校验tar包中的文件是否包含不允许的文件类型。
     *
     * @param tarFilePath          TAR文件的路径
     * @param disallowedExtensions 不允许的扩展名列表
     * @return 如果TAR包包含不允许的文件类型则返回false；否则返回true
     */
public static boolean validateTarFileContainsDisallowedFileTypes(String tarFilePath, List<String> disallowedExtensions) {
    try (FileInputStream fis = new FileInputStream(tarFilePath);
        TarInputStream tis = new TarInputStream(fis)) {
        TarEntry entry;
        while ((entry = tis.getNextEntry()) != null) {
            String fileName = entry.getName();
            // 检查是否是文件（而不是文件夹）
            if (!entry.isDirectory()) {
                String extension = getFileExtension(fileName);
                // 如果扩展名为空（即没有扩展名），则跳过当前文件，不进行校验
                if (extension == null) {
                    continue;
                }
                // 如果扩展名在不允许的列表中，返回false
                if (disallowedExtensions.contains(extension.toLowerCase())) {
                    return false;
                }
            }
        }
    } catch (IOException e) {
        log.info("Tar包校验异常: {}", e);
        return false;
    }
    // 如果没有发现不允许的文件类型，返回true
    return true;
}
### 类导入的包
org.apache.tools.tar.TarEntry
org.apache.tools.tar.TarInputStream
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为getFileExtension的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 从文件名中提取扩展名。
     *
     * @param fileName 文件名
     * @return 文件的扩展名，如果文件名中没有点号，则返回null
     */
private static String getFileExtension(String fileName) {
    int dotIndex = fileName.lastIndexOf('.');
    if (dotIndex == -1) {
        // 没有找到扩展名
        return null;
    }
    return fileName.substring(dotIndex + 1).toLowerCase();
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类FileUtil中有一个名为removeLastDirectoryFromPath的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除路径的最后一个目录
     *
     * @param path
     * @return
     */
public static String removeLastDirectoryFromPath(String path) {
    // 查找最后一个目录分隔符
    int lastSlashIndex = path.lastIndexOf('/');
    // 如果找不到目录分隔符（例如，路径是根目录或只有文件名），则直接返回原路径
    if (lastSlashIndex == -1) {
        return path;
    }
    // 截取最后一个目录分隔符之前的部分，即去除最后一个目录
    return path.substring(0, lastSlashIndex);
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类JobTemplateObject中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String jsonString = "{ \"name\":\"job-2\", \"core\":2, \"memorySize\":\"16G\", \"gpu\":{ \"cardNumber\":\"1\", \"computingPower\":\"50\", \"gpuSize\":\"8000\" }, \"image\":\"132.121.94.24:32000/training/automark:v1\", \"commandAndArgs\":\"python /home/automark_predict_images.py --train_path=/trainDataset/csv/train.csv --test_path=/trainDataset/csv/test.csv --nanli_path=/trainDataset/csv/nanli.csv --model_out=/out/model_out;while true;do echo hello;sleep 1;done\", \"volumes\":[ { \"name\":\"volume-0\", \"path\":\"/cephfs/dataset/picture/542/datasets\", \"mountPath\":\"/trainDataset\" }, { \"name\":\"volume-1\", \"path\":\"/cephfs/dataset/picture/542/modelout\", \"mountPath\":\"/out\" } ]}";
    JSONObject jsonObject = JSON.parseObject(jsonString);
    JobTemplateObject jobTemplateObject = jsonObject.toJavaObject(JobTemplateObject.class);
    System.out.println(jobTemplateObject.toString());
    String s = JSONObject.toJSONString(jobTemplateObject);
    System.out.println(s);
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
lombok.Data
### 类级别的变量
public String name;
public int core;
public String memorySize;
public GPU gpu;
public String image;
public String commandAndArgs;
public Volumes[] volumes;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getK8sClient的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ApiClient getK8sClient(String clusterName) throws Exception {
    log.info("获取k8s客户端{}, 开始..........", clusterName);
    if (StringUtils.isEmpty(clusterName)) {
        return apiClient;
    }
    //获取config
    ApiClient apiClient = null;
    Reader reader = null;
    try {
        org.springframework.core.io.Resource resource = new ClassPathResource(clusterName);
        reader = new InputStreamReader(resource.getInputStream());
        //加载k8s, config
        apiClient = ClientBuilder.kubeconfig(KubeConfig.loadKubeConfig(reader)).build();
        log.info("获取k8s客户端{}, 成功..........", clusterName);
    } catch (Exception e) {
        log.info("获取k8s客户端{}, 异常..........", clusterName);
        throw e;
    } finally {
        IOUtils.closeQuietly(reader);
    }
    return apiClient;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
org.apache.commons.io.IOUtils
org.apache.commons.lang3.StringUtils
org.springframework.core.io.ClassPathResource
javax.annotation.Resource
java.io.InputStream
java.io.InputStreamReader
java.io.Reader
### 类级别的变量
public ApiClient apiClient = null;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getCoreV1Api的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public CoreV1Api getCoreV1Api(String clusterName) throws Exception {
    CoreV1Api api = new CoreV1Api();
    // 切换对应集群客户端
    if (StringUtils.isNotEmpty(clusterName)) {
        api = new CoreV1Api(getK8sClient(clusterName));
    }
    return api;
}
### 类导入的包
io.kubernetes.client.openapi.apis.CoreV1Api
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getAppsV1Api的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public AppsV1Api getAppsV1Api(String clusterName) throws Exception {
    AppsV1Api appsV1Api = new AppsV1Api();
    if (StringUtils.isNotEmpty(clusterName)) {
        appsV1Api = new AppsV1Api(getK8sClient(clusterName));
    }
    return appsV1Api;
}
### 类导入的包
io.kubernetes.client.openapi.apis.AppsV1Api
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getBatchV1Api的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public BatchV1Api getBatchV1Api(String clusterName) throws Exception {
    BatchV1Api batchV1Api = new BatchV1Api();
    if (StringUtils.isNotEmpty(clusterName)) {
        batchV1Api = new BatchV1Api(getK8sClient(clusterName));
    }
    return batchV1Api;
}
### 类导入的包
io.kubernetes.client.openapi.apis.BatchV1Api
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为loadYamlFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String loadYamlFile(String fileName) throws IOException {
    org.springframework.core.io.Resource resource = new ClassPathResource(fileName);
    try (Reader reader = new InputStreamReader(resource.getInputStream());
        BufferedReader bufferedReader = new BufferedReader(reader)) {
        StringBuilder stringBuilder = new StringBuilder();
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            stringBuilder.append(line);
            // 添加换行符
            stringBuilder.append(System.lineSeparator());
        }
        return stringBuilder.toString();
    }
}
### 类导入的包
org.springframework.core.io.ClassPathResource
javax.annotation.Resource
java.io.BufferedReader
java.io.InputStream
java.io.InputStreamReader
java.io.Reader
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getYamlFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String getYamlFile(String fileName) throws IOException {
    if ("Job.yaml".equals(fileName)) {
        return jobYmlContent;
    } else if ("Deployment.yaml".equals(fileName)) {
        return deployYmlContent;
    } else if ("Service.yaml".equals(fileName)) {
        return serviceYmlContent;
    } else if ("UpgradeDeployment.yaml".equals(fileName)) {
        return upgradeDeployYmlContent;
    } else if ("ResourceQuota.yaml".equals(fileName)) {
        return resourceRuotaYmlContent;
    }
    return "";
}
### 类导入的包
javax.annotation.Resource
### 类级别的变量
public static String jobYmlContent = "";
public static String deployYmlContent = "";
public static String serviceYmlContent = "";
public static String upgradeDeployYmlContent = "";
public static String resourceRuotaYmlContent = "";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为loadAllYamlFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void loadAllYamlFile() throws IOException {
    log.info("K8sClientOperator 取yaml文件成功..........");
    jobYmlContent = loadYamlFile("yaml/Job.yaml");
    deployYmlContent = loadYamlFile("yaml/Deployment.yaml");
    serviceYmlContent = loadYamlFile("yaml/Service.yaml");
    upgradeDeployYmlContent = loadYamlFile("yaml/UpgradeDeployment.yaml");
    resourceRuotaYmlContent = loadYamlFile("yaml/ResourceQuota.yaml");
}
### 类导入的包
javax.annotation.Resource
### 类级别的变量
public static String jobYmlContent = "";
public static String deployYmlContent = "";
public static String serviceYmlContent = "";
public static String upgradeDeployYmlContent = "";
public static String resourceRuotaYmlContent = "";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为watchLogV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void watchLogV2(JSONObject context, OutputStream outputStream) throws Exception {
    if (context == null) {
        return;
    }
    PodLogs logs = new PodLogs();
    CoreV1Api api = new CoreV1Api();
    String podName = context.getString("podName");
    String labelName = context.getString("labelName");
    String namespace = context.getString("namespace");
    if (StringUtils.isEmpty(namespace)) {
        namespace = "default";
    }
    Integer tailLines = context.getInteger("tailLines");
    if (tailLines == null) {
        tailLines = 500;
    }
    String sinceSeconds = context.getString("sinceSeconds");
    //podName 重启后会变 需要重新查
    //        if (StringUtils.isEmpty(labelName)) {
    //            return;
    //        }
    //        log.info("labelName:" + labelName);
    //        V1PodList pods =
    //                api.listNamespacedPod(
    //                        namespace, "false", null, null,
    //                        null, labelName, null, null, null,
    //                        null, null);
    //        if (pods != null && pods.getItems().size() > 0) {
    //            V1Pod pod = pods.getItems().get(0);
    //            podName = pod.getMetadata().getName();
    //            log.info("podName:" + podName);
    //        }
    log.info("podName:" + podName);
    if (Objects.equals(context.getString("follow"), "true")) {
        try (InputStream is = logs.streamNamespacedPodLog(namespace, podName, null, null, tailLines, false)) {
            Streams.copy(is, outputStream);
        }
    } else {
        String podLogs = api.readNamespacedPodLog(podName, namespace, null, null, null, null, null, null, null, tailLines, null);
        if (podLogs != null) {
            outputStream.write(podLogs.getBytes());
        }
    }
}
### 类导入的包
io.kubernetes.client.PodLogs
io.kubernetes.client.openapi.apis.CoreV1Api
org.apache.commons.lang3.StringUtils
java.io.InputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为replaceDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public V1Deployment replaceDeployment(V1Deployment body, String name, String namespace) throws Exception {
    //        ApiClient client = k8sInit2.getConnection();
    AppsV1Api appsInstance = new AppsV1Api();
    String pretty = null;
    String dryRun = null;
    String fieldManager = null;
    V1Deployment deployment = appsInstance.replaceNamespacedDeployment(name, namespace, body, pretty, dryRun, fieldManager);
    return deployment;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为createDeployment的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public V1Deployment createDeployment(V1Deployment body, String namespace) throws Exception {
    //        ApiClient client = k8sInit2.getConnection();
    AppsV1Api appsInstance = new AppsV1Api();
    String pretty = null;
    String dryRun = null;
    String fieldManager = null;
    V1Deployment deployment = appsInstance.createNamespacedDeployment(namespace, body, pretty, dryRun, fieldManager);
    return deployment;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.AppsV1Api
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为createService的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public V1Service createService(V1Service body, String namespace) throws Exception {
    //        ApiClient client = k8sInit2.getConnection();
    CoreV1Api apiInstance = new CoreV1Api();
    String pretty = null;
    String dryRun = null;
    String fieldManager = null;
    V1Service service = apiInstance.createNamespacedService(namespace, body, pretty, dryRun, fieldManager);
    return service;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.CoreV1Api
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为createJobV2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public V1Job createJobV2(V1Job yamlJob, String namespace) throws Exception {
    BatchV1Api appsInstance = new BatchV1Api();
    String pretty = "true";
    String dryRun = null;
    String fieldManager = null;
    V1Job job = appsInstance.createNamespacedJob(namespace, yamlJob, pretty, dryRun, fieldManager);
    return job;
}
### 类导入的包
io.kubernetes.client.openapi.apis.BatchV1Api
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为createJob的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public V1Job createJob(V1Job body, String namespace) throws Exception {
    //        ApiClient client = k8sInit2.getConnection();
    BatchV1Api appsInstance = new BatchV1Api();
    String pretty = "true";
    String dryRun = null;
    String fieldManager = null;
    V1Job job = appsInstance.createNamespacedJob(namespace, body, pretty, dryRun, fieldManager);
    return job;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.apis.BatchV1Api
### 类级别的变量
@Resource
private K8sInit2 k8sInit2;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为checkPodStatus的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public boolean checkPodStatus(String namespace, String labelSelector, Integer timeoutSeconds) throws Exception {
    CoreV1Api api = new CoreV1Api();
    Watch<V1Pod> watch = Watch.createWatch(apiClient, api.listNamespacedPodCall(namespace, null, null, null, null, labelSelector, null, null, null, timeoutSeconds, true, null), new TypeToken<Watch.Response<V1Pod>>() {
    }.getType());
    try {
        for (Watch.Response<V1Pod> item : watch) {
            if (Objects.equals(item.object.getStatus().getPhase(), "Running")) {
                List<V1ContainerStatus> containerStatuses = item.object.getStatus().getContainerStatuses();
                if (containerStatuses != null) {
                    V1ContainerState state = containerStatuses.get(0).getState();
                    if (state.getRunning() != null) {
                        return true;
                    }
                }
            }
        }
        return false;
    } finally {
        watch.close();
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.google.gson.reflect.TypeToken
io.kubernetes.client.openapi.apis.CoreV1Api
### 类级别的变量
public ApiClient apiClient = null;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getContainerState的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public ContainerState getContainerState(String namespace, String podLabelSelector) throws Exception {
    ContainerState containerState = new ContainerState();
    CoreV1Api api = new CoreV1Api();
    V1PodList pods = api.listNamespacedPod(namespace, null, null, null, null, podLabelSelector, null, null, null, null, null);
    pods.getItems().forEach(pod -> {
        String podName = pod.getMetadata().getName();
        V1ContainerState state = pod.getStatus().getContainerStatuses().get(0).getState();
        OffsetDateTime creationTimestamp = pod.getMetadata().getCreationTimestamp();
        containerState.setPodName(podName);
        containerState.setCreationTimestamp(creationTimestamp);
        if (state.getRunning() != null) {
            containerState.setState(V1ContainerState.SERIALIZED_NAME_RUNNING);
            log.info(String.format("%s\t%s\t", podName, V1ContainerState.SERIALIZED_NAME_RUNNING));
        } else if (state.getWaiting() != null) {
            containerState.setState(V1ContainerState.SERIALIZED_NAME_WAITING);
            containerState.setReason(state.getWaiting().getReason());
            containerState.setMessage(state.getWaiting().getMessage());
            log.info(String.format("%s\t%s\t%s\t%s\t", podName, V1ContainerState.SERIALIZED_NAME_WAITING, state.getWaiting().getReason(), state.getWaiting().getMessage()));
        } else if (state.getTerminated() != null) {
            containerState.setState(V1ContainerState.SERIALIZED_NAME_TERMINATED);
            containerState.setReason(state.getTerminated().getReason());
            containerState.setMessage(state.getTerminated().getMessage());
            log.info(String.format("%s\t%s\t%s\t%s\t", podName, V1ContainerState.SERIALIZED_NAME_TERMINATED, state.getTerminated().getReason(), state.getTerminated().getMessage()));
        } else {
            containerState.setState("未知状态");
            log.info(String.format("%s\t%s\t", podName, "未知状态"));
        }
    });
    return containerState;
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
io.kubernetes.client.openapi.apis.CoreV1Api
java.time.OffsetDateTime
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getEvents的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public List<Event> getEvents(String namespace, String podName) throws Exception {
    List<Event> events = new ArrayList<>();
    CoreV1Api api = new CoreV1Api();
    CoreV1EventList eventList = api.listNamespacedEvent(namespace, null, null, null, "involvedObject.name=" + podName, null, null, null, null, null, null);
    for (CoreV1Event ev : eventList.getItems()) {
        Event event = new Event();
        event.setType(ev.getType());
        event.setReason(ev.getReason());
        event.setMessage(ev.getMessage());
        event.setFirstTimestamp(ev.getFirstTimestamp() != null ? ev.getFirstTimestamp().toString() : "");
        event.setLastTimestamp(ev.getLastTimestamp() != null ? ev.getLastTimestamp().toString() : "");
        event.setCount(ev.getCount());
        events.add(event);
    }
    return events;
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.Event
io.kubernetes.client.openapi.apis.CoreV1Api
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为createNamespaceIfNotExist的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 查找namespace是否存在，不存在自动创建
     *
     * @param namespace
     * @return
     * @throws Exception
     */
public V1Namespace createNamespaceIfNotExist(String namespace) throws Exception {
    CoreV1Api api = new CoreV1Api();
    try {
        return api.readNamespace(namespace, null);
    } catch (ApiException e) {
        return createNamespace(namespace);
    }
}
### 类导入的包
io.kubernetes.client.openapi.ApiException
io.kubernetes.client.openapi.apis.CoreV1Api
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getPodMetric的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public MetricsVo getPodMetric(String namespace, String podName) throws Exception {
    MetricsVo metrics = new MetricsVo();
    Pair<V1Pod, PodMetrics> pod = topPod(namespace, podName);
    if (pod == null) {
        return metrics;
    }
    try {
        log.debug("getPodMetric pod name:{}", pod.getLeft().getMetadata().getName());
        if (pod.getRight() != null) {
            ContainerMetrics containerMetrics = new ContainerMetrics();
            for (ContainerMetrics container : pod.getRight().getContainers()) {
                if (pod.getLeft().getMetadata().getName().contains(container.getName())) {
                    containerMetrics = container;
                }
            }
            metrics = new MetricsVo(pod.getLeft().getMetadata().getNamespace(), pod.getLeft().getMetadata().getName(), pod.getLeft().getSpec().getNodeName(), toContainerState(pod.getLeft().getStatus().getContainerStatuses().get(0).getState()), containerMetrics.getUsage().get("cpu").toSuffixedString(), pod.getLeft().getSpec().getContainers().get(0).getResources().getRequests() == null ? "" : pod.getLeft().getSpec().getContainers().get(0).getResources().getRequests().get("cpu").toSuffixedString(), containerMetrics.getUsage().get("memory").toSuffixedString(), pod.getLeft().getSpec().getContainers().get(0).getResources().getRequests() == null ? "" : pod.getLeft().getSpec().getContainers().get(0).getResources().getRequests().get("memory").toSuffixedString());
        } else {
            metrics = new MetricsVo(pod.getLeft().getMetadata().getNamespace(), pod.getLeft().getMetadata().getName(), pod.getLeft().getSpec().getNodeName(), toContainerState(pod.getLeft().getStatus().getContainerStatuses().get(0).getState()), "0", "0", "0", "0");
        }
        metrics.calculationPercent();
    } catch (Exception e) {
        log.info("获取top数据失败：" + e.getMessage());
    }
    return metrics;
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
com.eshore.gdai.trainingcenter.vo.pod.MetricsVo
io.kubernetes.client.Metrics
io.kubernetes.client.custom.ContainerMetrics
io.kubernetes.client.custom.PodMetrics
org.apache.commons.lang3.tuple.Pair
javax.annotation.Resource
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为topPod的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private Pair<V1Pod, PodMetrics> topPod(String namespace, String podName) throws KubectlException, ApiException, IOException {
    CoreV1Api api = new CoreV1Api();
    V1Pod pod = api.readNamespacedPod(podName, namespace, null);
    PodMetricsList metrics = new Metrics(apiClient).getPodMetrics(namespace);
    for (PodMetrics metric : metrics.getItems()) {
        if (metric.getMetadata().getName().equals(podName)) {
            return new ImmutablePair<>((V1Pod) pod, metric);
        }
    }
    return null;
}
### 类导入的包
io.kubernetes.client.Metrics
io.kubernetes.client.custom.PodMetrics
io.kubernetes.client.custom.PodMetricsList
io.kubernetes.client.openapi.apis.CoreV1Api
org.apache.commons.lang3.tuple.ImmutablePair
org.apache.commons.lang3.tuple.Pair
### 类级别的变量
public ApiClient apiClient = null;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为toContainerState的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private ContainerState toContainerState(V1ContainerState containerState) {
    ContainerState state = new ContainerState();
    if (containerState.getRunning() != null) {
        state.setState(V1ContainerState.SERIALIZED_NAME_RUNNING);
    } else if (containerState.getWaiting() != null) {
        state.setState(V1ContainerState.SERIALIZED_NAME_WAITING);
        state.setReason(containerState.getWaiting().getReason());
        state.setMessage(containerState.getWaiting().getMessage());
    } else if (containerState.getTerminated() != null) {
        state.setState(V1ContainerState.SERIALIZED_NAME_TERMINATED);
        state.setReason(containerState.getTerminated().getReason());
        state.setMessage(containerState.getTerminated().getMessage());
    } else {
        state.setState("未知状态");
    }
    return state;
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.pod.ContainerState
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为getTimestamp的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String getTimestamp(OffsetDateTime offsetDateTime) {
    if (offsetDateTime != null) {
        // 获取系统默认的时区
        ZoneId systemDefaultZoneId = ZoneId.systemDefault();
        // 将OffsetDateTime转换为ZonedDateTime，然后使用系统默认时区
        ZonedDateTime zonedDateTime = offsetDateTime.atZoneSameInstant(systemDefaultZoneId);
        // 如果你只需要LocalDateTime（不包含时区信息），可以进一步转换
        LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
        // 将LocalDateTime转换为String，输出格式为"yyyy-MM-dd HH:mm:ss"
        return localDateTime.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }
    return "";
}
### 类导入的包
java.time.LocalDateTime
java.time.OffsetDateTime
java.time.ZoneId
java.time.ZonedDateTime
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sClientOperator中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) throws ApiException, IOException, InterruptedException {
    log.info("k8s初始化开始..........");
    //获取config
    ApiClient apiClient = null;
    Reader reader = null;
    try {
        org.springframework.core.io.Resource resource = new ClassPathResource("config_local");
        reader = new InputStreamReader(resource.getInputStream());
        //加载k8s, config
        apiClient = ClientBuilder.kubeconfig(KubeConfig.loadKubeConfig(reader)).build();
        //将加载config的client设置为默认的client
        Configuration.setDefaultApiClient(apiClient);
        log.info("k8s初始化成功..........");
    } catch (Exception e) {
        log.info("k8s初始化异常..........");
        e.printStackTrace();
    } finally {
        IOUtils.closeQuietly(reader);
    }
    //        CoreV1Api apiInstances = new CoreV1Api(apiClient);
    //        V1PodList v1PodList = apiInstances.listNamespacedPod("", null, null, null, null, null, null, null, null, null, null);
    //        System.out.println(v1PodList.toString());
    //        Exec exec = new Exec();
    //        // final Process proc = exec.exec("default", "nginx-4217019353-k5sn9", new String[]
    //        //   {"sh", "-c", "echo foo"}, true, tty);
    //        String[] cmds = {"jupyter", "notebook", "list"};
    //        final Process proc =
    //                exec.exec("default", "jupyter-algorithm-20230300094-568749c679-vjcdt", cmds, true, true);
    //        JSONObject res = new JSONObject();
    //        Thread out = new Thread(
    //                new Runnable() {
    //                    public void run() {
    //                        String copy = copy(proc.getInputStream());
    //                        res.put("data", copy);//
    //                    }
    //                });
    //        out.start();
    //        proc.waitFor();
    //        out.join();
    //        proc.destroy();
    //
    //        if (proc.exitValue() != 0) {
    //            res.put("success", false);
    //        } else {
    //            res.put("success", true);
    //        }
    //
    //        System.out.println(JSONObject.toJSONString(res));
    //        CoreV1Api api = new CoreV1Api();
    //
    //        PodLogs logs = new PodLogs();
    //        V1Pod pod =
    //                api.listNamespacedPod(
    //                        "default", "false", null, null, null, null, null, null, null, null, null)
    //                        .getItems()
    //                        .get(0);
    //
    //        InputStream is = logs.streamNamespacedPodLog(pod);
    //        String token = null;
    //        BufferedReader br = new BufferedReader(
    //                new InputStreamReader(is,
    //                        Charset.forName("utf8")));
    //        String line;
    //        boolean keepRunning = true;
    //        long startTime = System.currentTimeMillis();
    //        while (br.read() != -1) {
    //            line = br.readLine();
    //            if (!line.trim().equals("")) {
    //                int index1 = line.indexOf("lab?token=");
    //                if (index1 >= 0) {
    //                    int indexServerApp = line.indexOf("ServerApp");
    //                    if (indexServerApp >= 0) {
    //                        token = (line.substring(index1 + 10, index1 + 10 + 48));
    //                        System.out.println(token);
    //                    }
    //                }
    //            }
    //        }
    //        is.close();
    //        br.close();
    CoreV1Api api = new CoreV1Api();
    Watch<Object> watch = Watch.createWatch(apiClient, api.readNamespacedPodLogCall("train-service-1182-557c5d489f-cxxh8", "default", null, null, null, null, null, null, null, 500, null, null), new TypeToken<Watch.Response<Object>>() {
    }.getType());
    try {
        for (Watch.Response<Object> item : watch) {
            log.info(String.format("%s : %s ", "log:", item.object));
        }
    } finally {
        watch.close();
    }
    //        Watch<V1Pod> watch = Watch.createWatch(
    //                apiClient,
    //                api.listNamespacedPodCall("", null, null, null, null,
    //                        "jupyter-algorithm-20230300100", null, null, null, 60, true, null),
    //                new TypeToken<Watch.Response<V1Pod>>() {
    //                }.getType());
    //
    //        try {
    //            for (Watch.Response<V1Pod> item : watch) {
    //                log.info(String.format("%s : %s : %s%n", item.object.getMetadata().getName(), item.type, item.object.getStatus().getPhase()));
    //                if (Objects.equals(item.object.getStatus().getPhase(), "Running")) {
    //                    System.out.println(item.object.getStatus().getPhase());
    //                    return;
    //                }
    //            }
    //            return;
    //        } finally {
    //            watch.close();
    //        }
}
### 类导入的包
com.alibaba.fastjson.JSONObject
com.google.gson.reflect.TypeToken
io.kubernetes.client.PodLogs
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.Configuration
io.kubernetes.client.openapi.apis.CoreV1Api
org.apache.commons.io.IOUtils
org.springframework.core.io.ClassPathResource
javax.annotation.Resource
java.io.BufferedReader
java.io.InputStream
java.io.InputStreamReader
java.io.Reader
### 类级别的变量
public ApiClient apiClient = null;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sInit中有一个名为getConnection的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * k8s的初始化
     *
     * @return
     */
public synchronized ApiClient getConnection() {
    InputStream in = null;
    ApiClient apiClient = null;
    try {
        // 输入流从 resources 中读取 config
        in = ClassLoader.getSystemResourceAsStream("config");
        // 配置客户端
        apiClient = Config.fromConfig(in);
        ApiKeyAuth BearerToken = (ApiKeyAuth) apiClient.getAuthentications().get("BearerToken");
        BearerToken.setApiKey(token);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (in != null) {
                in.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return apiClient;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.auth.ApiKeyAuth
io.kubernetes.client.util.Config
java.io.IOException
java.io.InputStream
### 类级别的变量
@Value("${config.k8s-token}")
private String token;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sInit中有一个名为getConnection4Query的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * k8s的初始化, 用于查询不用Token
     *
     * @return
     */
public synchronized ApiClient getConnection4Query() {
    InputStream in = null;
    ApiClient apiClient4Query = null;
    try {
        // 输入流从 resources 中读取 config
        in = ClassLoader.getSystemResourceAsStream("config");
        // 配置客户端
        apiClient4Query = Config.fromConfig(in);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (in != null) {
                in.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return apiClient4Query;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.util.Config
java.io.IOException
java.io.InputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类K8sInit2中有一个名为getConnection的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * k8s的初始化
     *
     * @return
     */
public synchronized ApiClient getConnection() {
    log.info("k8s初始化开始..........");
    //获取config
    ApiClient apiClient = null;
    Reader reader = null;
    try {
        Resource resource = new ClassPathResource("config_new");
        reader = new InputStreamReader(resource.getInputStream());
        //加载k8s, config
        apiClient = ClientBuilder.kubeconfig(KubeConfig.loadKubeConfig(reader)).build();
        //将加载config的client设置为默认的client
        Configuration.setDefaultApiClient(apiClient);
        log.info("k8s初始化成功..........");
    } catch (Exception e) {
        log.info("k8s初始化异常..........");
        e.printStackTrace();
    } finally {
        IOUtils.closeQuietly(reader);
    }
    return apiClient;
}
### 类导入的包
io.kubernetes.client.openapi.ApiClient
io.kubernetes.client.openapi.Configuration
io.kubernetes.client.util.ClientBuilder
io.kubernetes.client.util.KubeConfig
org.apache.commons.io.IOUtils
org.springframework.core.io.ClassPathResource
org.springframework.core.io.Resource
java.io.InputStreamReader
java.io.Reader
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类LocalUpload中有一个名为checkFileMd5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Result<?> checkFileMd5(String fileMd5, String fileName, String confFilePath, String tmpFilePath) throws Exception {
    boolean isParamEmpty = StringUtils.isBlank(fileMd5) || StringUtils.isBlank(fileName) || StringUtils.isBlank(confFilePath) || StringUtils.isBlank(tmpFilePath);
    if (isParamEmpty) {
        throw new Exception("参数值为空");
    } else {
        File confFile = FileUtils.getFile(confFilePath + File.separatorChar + fileName + ".conf");
        boolean isTmpFileEmpty = (FileUtils.getFile(tmpFilePath + File.separatorChar + fileName + "_tmp")).exists();
        if (confFile.exists() && isTmpFileEmpty) {
            byte[] completeList = FileUtils.readFileToByteArray(confFile);
            List<String> missChunkList = new LinkedList();
            for (int i = 0; i < completeList.length; ++i) {
                if (completeList[i] != 127) {
                    missChunkList.add(Integer.toString(i));
                }
            }
            JSONArray jsonArray = JSON.parseArray(JSONObject.toJSONString(missChunkList));
            return Result.ok(HttpStatus.PARTIAL_CONTENT.value(), "文件已经上传了一部分", jsonArray);
        } else {
            boolean isFileEmpty = (FileUtils.getFile(tmpFilePath + File.separatorChar + fileName)).exists();
            return isFileEmpty && confFile.exists() ? Result.ok(HttpStatus.OK.value(), "文件已上传成功") : Result.ok(HttpStatus.NOT_FOUND.value(), "文件不存在");
        }
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.io.FileUtils
org.apache.commons.lang.StringUtils
org.springframework.http.HttpStatus
java.io.File
java.util.LinkedList
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类LocalUpload中有一个名为fragmentFileUploader的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static synchronized Result<?> fragmentFileUploader(UploadFileParam param, String confFilePath, String filePath, long chunkSize, HttpServletRequest request) throws Exception {
    RandomAccessFile accessConfFile = null;
    RandomAccessFile accessTmpFile = null;
    try {
        boolean isParamEmpty = StringUtils.isBlank(filePath) || StringUtils.isBlank(confFilePath) && param.getFile() == null;
        if (isParamEmpty) {
            throw new Exception("参数值为空");
        } else {
            boolean isMultipart = ServletFileUpload.isMultipartContent(request);
            if (!isMultipart) {
                throw new IllegalArgumentException("上传内容不是有效的multipart/form-data类型.");
            } else {
                File confFile = cn.hutool.core.io.FileUtil.file(cn.hutool.core.io.FileUtil.mkdir(confFilePath), String.format("%s.conf", param.getName()));
                accessConfFile = new RandomAccessFile(confFile, "rw");
                accessConfFile.setLength(param.getChunks());
                accessConfFile.seek(param.getChunk());
                accessConfFile.write(127);
                File tmpFile = cn.hutool.core.io.FileUtil.file(cn.hutool.core.io.FileUtil.mkdir(filePath), String.format("%s_tmp", param.getName()));
                accessTmpFile = new RandomAccessFile(tmpFile, "rw");
                long offset = chunkSize * (long) param.getChunk();
                accessTmpFile.seek(offset);
                accessTmpFile.write(param.getFile().getBytes());
                byte[] completeList = FileUtils.readFileToByteArray(confFile);
                byte isComplete = 127;
                for (int i = 0; i < completeList.length && isComplete == 127; ++i) {
                    isComplete &= completeList[i];
                }
                if (isComplete != 127) {
                    return Result.ok(HttpStatus.OK.value(), "文件上传成功");
                } else {
                    boolean isSuccess = renameFile(tmpFile, param.getName());
                    if (!isSuccess) {
                        throw new Exception("文件重命名时失败");
                    } else {
                        FileInfo fileInfo = FileInfo.builder().hash(param.getMd5()).name(param.getName()).type(param.getFile().getContentType()).path(tmpFile.getParent() + File.separatorChar + param.getName()).createTime(System.currentTimeMillis()).build();
                        return Result.ok(HttpStatus.CREATED.value(), "文件上传完成", fileInfo);
                    }
                }
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
        return Result.error("文件上传失败");
    } finally {
        if (accessTmpFile != null) {
            try {
                accessTmpFile.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (accessConfFile != null) {
            try {
                accessConfFile.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.FileInfo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.fileupload.servlet.ServletFileUpload
org.apache.commons.io.FileUtils
org.apache.commons.lang.StringUtils
org.springframework.http.HttpStatus
java.io.File
java.io.IOException
java.io.RandomAccessFile
java.util.List
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类LocalUpload中有一个名为regularFileUploader的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Result<?> regularFileUploader(UploadFileParam param, String filePath) throws Exception {
    boolean isParamEmpty = StringUtils.isBlank(filePath) || StringUtils.isBlank(param.getName()) && param.getFile() == null;
    if (isParamEmpty) {
        throw new Exception("参数值为空");
    } else {
        File uploadFolder = new File(filePath);
        if (!uploadFolder.exists() && !uploadFolder.mkdirs()) {
            return Result.fail(HttpStatus.FORBIDDEN.value(), "上传所需文件夹创建失败");
        } else {
            File uploadFile = new File(filePath + File.separatorChar + param.getName());
            param.getFile().transferTo(uploadFile);
            if (uploadFile.length() != param.getFile().getSize()) {
                return Result.error("文件上传失败");
            } else {
                FileInfo fileInfo = FileInfo.builder().hash(param.getMd5()).name(param.getName()).type(param.getFile().getContentType()).path(uploadFile.getPath()).createTime(System.currentTimeMillis()).build();
                return Result.ok(HttpStatus.CREATED.value(), "文件上传完成", fileInfo);
            }
        }
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.vo.FileInfo
com.eshore.gdai.trainingcenter.vo.Result
org.apache.commons.lang.StringUtils
org.springframework.http.HttpStatus
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类LocalUpload中有一个名为regularFileUploader的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Result<?> regularFileUploader(UploadFileParam param) throws Exception {
    boolean isParamEmpty = StringUtils.isBlank(param.getName()) && param.getFile() == null;
    if (isParamEmpty) {
        throw new Exception("参数值为空");
    } else {
        param.setName(System.currentTimeMillis() + param.getName().substring(param.getName().lastIndexOf(".")));
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(String.format("yyyy%sMM%sdd", File.separatorChar, File.separatorChar));
        return regularFileUploader(param, defaultPath + File.separatorChar + simpleDateFormat.format(System.currentTimeMillis()));
    }
}
### 类导入的包
org.apache.commons.lang.StringUtils
java.io.File
java.text.SimpleDateFormat
### 类级别的变量
public static String defaultPath;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类LocalUpload中有一个名为renameFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private static boolean renameFile(File toBeRenamed, String toFileNewName) {
    if (toBeRenamed.exists() && !toBeRenamed.isDirectory()) {
        File newFile = FileUtils.getFile(toBeRenamed.getParent() + File.separatorChar + toFileNewName);
        return toBeRenamed.renameTo(newFile);
    } else {
        return false;
    }
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类MapUrlParamsUtils中有一个名为getUrlParams的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将url参数转换成map
     *
     * @param param aa=11&bb=22&cc=33
     * @return
     */
public static Map<String, String> getUrlParams(String param) {
    Map<String, String> map = new HashMap<String, String>(0);
    if (StringUtils.isBlank(param)) {
        return map;
    }
    String[] params = param.split("&");
    for (int i = 0; i < params.length; i++) {
        String[] p = params[i].split("=");
        if (p.length == 2) {
            map.put(p[0], p[1]);
        }
    }
    return map;
}
### 类导入的包
java.util.HashMap
java.util.Map
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类MapUrlParamsUtils中有一个名为getUrlParamsByMap的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将map转换成url
     *
     * @param map
     * @return
     */
public static String getUrlParamsByMap(Map<String, Object> map) {
    if (map == null) {
        return "";
    }
    StringBuffer sb = new StringBuffer();
    for (Map.Entry<String, Object> entry : map.entrySet()) {
        sb.append(entry.getKey() + "=" + entry.getValue());
        sb.append("&");
    }
    String s = sb.toString();
    if (s.endsWith("&")) {
        s = StringUtils.substringBeforeLast(s, "&");
    }
    return s;
}
### 类导入的包
java.util.Map
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类Md5CaculateUtil中有一个名为getMD5的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取一个文件的md5值(可处理大文件)
     *
     * @return md5 value
     */
public static String getMD5(File file) {
    FileInputStream fileInputStream = null;
    try {
        MessageDigest MD5 = MessageDigest.getInstance("MD5");
        fileInputStream = new FileInputStream(file);
        byte[] buffer = new byte[8192];
        int length;
        while ((length = fileInputStream.read(buffer)) != -1) {
            MD5.update(buffer, 0, length);
        }
        return new String(Hex.encodeHex(MD5.digest()));
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    } finally {
        try {
            if (fileInputStream != null) {
                fileInputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
### 类导入的包
org.apache.commons.codec.binary.Hex
java.io.File
java.io.FileInputStream
java.io.IOException
java.security.MessageDigest
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类Md5CaculateUtil中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    //        long beginTime = System.currentTimeMillis();
    //        File file = new File("D:\\cephfs\\yolov5-base.tar.gz");
    //        String md5 = getMD5(file);
    //        long endTime = System.currentTimeMillis();
    //        System.out.println("MD5:" + md5 + "\n 耗时:" + ((endTime - beginTime) / 1000) + "s");
}
### 类导入的包
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ModelUtil中有一个名为createModel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static BaseModel createModel(String annotationType, String annotationTemplate, JSONObject labelData) {
    if (labelData == null) {
        labelData = JSON.parseObject("{}");
    }
    //图像
    if (Objects.equals(annotationType.toLowerCase(), "OBJDET".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "RECTANGLE".toLowerCase())) {
        //物体检测-矩形标注框
        return JSONObject.parseObject(JSON.toJSONString(labelData), Rectangle.class);
    } else if (Objects.equals(annotationType.toLowerCase(), "imgcls".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "imgcls".toLowerCase())) {
        //图像分类-单图单标签
        return JSONObject.parseObject(JSON.toJSONString(labelData), Imgcls.class);
    } else if (Objects.equals(annotationType.toLowerCase(), "segment".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Instance".toLowerCase())) {
        //图像分割-实例分割
        return JSONObject.parseObject(JSON.toJSONString(labelData), Instance.class);
    } else if (Objects.equals(annotationType.toLowerCase(), "segment".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Semantic".toLowerCase())) {
        //图像分割-语义分割
        return JSONObject.parseObject(JSON.toJSONString(labelData), Instance.class);
    } else //文本
    if (Objects.equals(annotationType.toLowerCase(), "Txtcls".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Txtcls".toLowerCase())) {
        //文本分类-单标签
        return JSONObject.parseObject(JSON.toJSONString(labelData), Txtcls.class);
    } else if (Objects.equals(annotationType.toLowerCase(), "Txtclsm".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "Txtclsm".toLowerCase())) {
        //文本分类-多标签
        return JSONObject.parseObject(JSON.toJSONString(labelData), Txtclsm.class);
    } else if (Objects.equals(annotationType.toLowerCase(), "TxtEntity".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "TxtEntity".toLowerCase())) {
        //文本实体抽取
        return JSONObject.parseObject(JSON.toJSONString(labelData), TxtEntity.class);
    } else //视频
    if (Objects.equals(annotationType.toLowerCase(), "videotracking".toLowerCase()) && Objects.equals(annotationTemplate.toLowerCase(), "videotracking".toLowerCase())) {
        //视频跟踪
        return JSONObject.parseObject(JSON.toJSONString(labelData), VideoTracking.class);
    } else {
        return null;
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
com.eshore.gdai.trainingcenter.model.pic.imgcls.Imgcls
com.eshore.gdai.trainingcenter.model.pic.object.Rectangle
com.eshore.gdai.trainingcenter.model.pic.segment.Instance
com.eshore.gdai.trainingcenter.model.txt.txtcls.Txtcls
com.eshore.gdai.trainingcenter.model.txt.txtclsm.Txtclsm
com.eshore.gdai.trainingcenter.model.txt.txtentity.TxtEntity
com.eshore.gdai.trainingcenter.model.video.videotracking.VideoTracking
java.util.Objects
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类NovelWebUtils中有一个名为forReturn的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 上传文件结果转换为本系统的结果
     *
     * @param result
     * @return
     */
public static RestResult<Object> forReturn(Result<Object> result) {
    if ("200".equals(result.getCode()) || "201".equals(result.getCode())) {
        return RestResult.genSuccessResult(result.getMessage(), result.getData());
    } else if ("206".equals(result.getCode())) {
        return RestResult.genResult(0, "16", result.getMessage(), result.getData());
    } else {
        return RestResult.genResult(0, "12", result.getMessage(), null);
    }
}
### 类导入的包
com.chinatelecom.dcoos.common.result.RestResult
com.eshore.gdai.trainingcenter.vo.Result
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类OkHttpUtils中有一个名为requestParams的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String requestParams(String httpMethod, String url, String parameter, Headers headers) throws IOException {
    logger.debug("HttpMethod: {}, Url: {}, Parameter: {}, Headers: {}", httpMethod, url, parameter, headers);
    Request request;
    String contentType = ObjectUtils.isEmpty(headers.get("content-type")) ? "application/json" : headers.get("content-type");
    if ("GET".equals(httpMethod)) {
        request = new Request.Builder().url(url).headers(headers).get().build();
    } else if ("POST".equals(httpMethod)) {
        request = new Request.Builder().url(url).post(FormBody.create(parameter, MediaType.parse(contentType))).headers(headers).build();
    } else if ("PUT".equals(httpMethod)) {
        request = new Request.Builder().url(url).put(FormBody.create(parameter, MediaType.parse(contentType))).headers(headers).build();
    } else if ("DELETE".equals(httpMethod)) {
        request = new Request.Builder().url(url).delete(FormBody.create(parameter, MediaType.parse(contentType))).headers(headers).build();
    } else if ("HEAD".equals(httpMethod)) {
        request = new Request.Builder().url(url).head().headers(headers).build();
    } else if ("PATCH".equals(httpMethod)) {
        request = new Request.Builder().url(url).patch(FormBody.create(parameter, MediaType.parse(contentType))).headers(headers).build();
    } else {
        throw new IOException("暂不支持该请求类型.");
    }
    String result = getPage(request);
    logger.info(" 请求URL:{} , 结果:{}", url, result);
    return result;
}
### 类导入的包
java.io.IOException
org.springframework.util.ObjectUtils
okhttp3.FormBody
okhttp3.Headers
okhttp3.MediaType
okhttp3.Request
### 类级别的变量
private static final Logger logger = LoggerFactory.getLogger(OkHttpUtils.class);

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类PwdUtil中有一个名为checkPwd的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 密码强度校验
     *
     * @param pwd
     * @param minLength
     * @return
     */
public static boolean checkPwd(String pwd, int minLength) {
    if (minLength == 0)
        minLength = 8;
    String req = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[\\W_])[A-Za-z\\d\\W_]{" + minLength + ",}";
    if (pwd.matches(req)) {
        return true;
    } else
        return false;
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RSAUtil中有一个名为decipherPrivateKey的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
	 * 
	 * @Description 私钥解密 
	 * @param content
	 * @param privateKey
	 * @return
	 * @throws Exception
	 * @author zhengchuanqing
	 * @date 2021年5月20日 下午1:17:56
	 */
public static String decipherPrivateKey(String content, String privateKey) throws Exception {
    ByteArrayOutputStream out = null;
    try {
        byte[] encryptedData = Base64.decodeBase64(content);
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        return new String(decryptedData);
    } catch (Exception e) {
        logger.error("RSA私钥加密>>>进行数据解密异常", e);
    } finally {
        if (out != null) {
            out.close();
        }
    }
    return null;
}
### 类导入的包
java.io.ByteArrayOutputStream
java.security.Key
java.security.KeyFactory
java.security.spec.PKCS8EncodedKeySpec
javax.crypto.Cipher
org.apache.commons.codec.binary.Base64
### 类级别的变量
private final static Logger logger = LoggerFactory.getLogger(RSAUtil.class);
//加密算法RSA
private static final String KEY_ALGORITHM = "RSA";
//RSA最大解密密文大小
private static final int MAX_DECRYPT_BLOCK = 128;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为expire的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
public boolean expire(String key, long time) {
    try {
        if (time > 0) {
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包
java.util.concurrent.TimeUnit
### 类级别的变量
@Autowired
private RedisTemplate<String, Object> redisTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为hasKey的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
public boolean hasKey(String key) {
    try {
        return redisTemplate.hasKey(key);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private RedisTemplate<String, Object> redisTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为del的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
public void del(String... key) {
    if (key != null && key.length > 0) {
        if (key.length == 1) {
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete(CollectionUtils.arrayToList(key));
        }
    }
}
### 类导入的包
org.springframework.util.CollectionUtils
java.util.List
### 类级别的变量
@Autowired
private RedisTemplate<String, Object> redisTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public T get(String key, Class<T> clazz, long expire) {
    String value = valueOperations.get(key);
    if (expire != NOT_EXPIRE) {
        redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }
    return value == null ? null : fromJson(value, clazz);
}
### 类导入的包
java.util.concurrent.TimeUnit
### 类级别的变量
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private ValueOperations<String, String> valueOperations;
/**
 * 不设置过期时长
 */
public final static long NOT_EXPIRE = -1;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为get的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String get(String key, long expire) {
    String value = valueOperations.get(key);
    if (expire != NOT_EXPIRE) {
        redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }
    return value;
}
### 类导入的包
java.util.concurrent.TimeUnit
### 类级别的变量
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private ValueOperations<String, String> valueOperations;
/**
 * 不设置过期时长
 */
public final static long NOT_EXPIRE = -1;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为hmset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
public boolean hmset(String key, Map<String, Object> map) {
    try {
        hashOperations.putAll(key, map);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private HashOperations<String, String, Object> hashOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为hmset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
public boolean hmset(String key, Map<String, Object> map, long time) {
    try {
        hashOperations.putAll(key, map);
        if (time > 0) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private HashOperations<String, String, Object> hashOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为hset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
public boolean hset(String key, String item, Object value) {
    try {
        hashOperations.put(key, item, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private HashOperations<String, String, Object> hashOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为hset的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
public boolean hset(String key, String item, Object value, long time) {
    try {
        hashOperations.put(key, item, value);
        if (time > 0) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private HashOperations<String, String, Object> hashOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为sGet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
public Set<Object> sGet(String key) {
    try {
        return setOperations.members(key);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private SetOperations<String, Object> setOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为sHasKey的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
public boolean sHasKey(String key, Object value) {
    try {
        return setOperations.isMember(key, value);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private SetOperations<String, Object> setOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为sSet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
public long sSet(String key, Object... values) {
    try {
        return setOperations.add(key, values);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private SetOperations<String, Object> setOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为sSetAndTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
public long sSetAndTime(String key, long time, Object... values) {
    try {
        Long count = setOperations.add(key, values);
        if (time > 0)
            expire(key, time);
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private SetOperations<String, Object> setOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为sGetSetSize的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
public long sGetSetSize(String key) {
    try {
        return setOperations.size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private SetOperations<String, Object> setOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为setRemove的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
public long setRemove(String key, Object... values) {
    try {
        Long count = setOperations.remove(key, values);
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private SetOperations<String, Object> setOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lGet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return
     */
public List<Object> lGet(String key, long start, long end) {
    try {
        return listOperations.range(key, start, end);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lGetListSize的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
public long lGetListSize(String key) {
    try {
        return listOperations.size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lGetIndex的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
public Object lGetIndex(String key, long index) {
    try {
        return listOperations.index(key, index);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lSet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
public boolean lSet(String key, Object value) {
    try {
        listOperations.rightPush(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lSet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
public boolean lSet(String key, Object value, long time) {
    try {
        listOperations.rightPush(key, value);
        if (time > 0)
            expire(key, time);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lSet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
public boolean lSet(String key, List<Object> value) {
    try {
        listOperations.rightPushAll(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lSet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将list放入缓存
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
public boolean lSet(String key, List<Object> value, long time) {
    try {
        listOperations.rightPushAll(key, value);
        if (time > 0)
            expire(key, time);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lUpdateIndex的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
public boolean lUpdateIndex(String key, long index, Object value) {
    try {
        listOperations.set(key, index, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为lRemove的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
public long lRemove(String key, long count, Object value) {
    try {
        Long remove = listOperations.remove(key, count, value);
        return remove;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}
### 类导入的包

### 类级别的变量
@Autowired
private ListOperations<String, Object> listOperations;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类RedisUtils中有一个名为hGet的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
//定义get方法，返回字节数组形式的Value
public byte[] hGet(byte[] key, byte[] hashKey) {
    return (byte[]) redisTemplate.execute((RedisCallback<byte[]>) redisConnection -> {
        byte[] bytes = redisConnection.hGet(key, hashKey);
        return bytes;
    });
}
### 类导入的包

### 类级别的变量
@Autowired
private RedisTemplate<String, Object> redisTemplate;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ReturnJson中有一个名为turnUiPageNotIncludeData的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static UiPage turnUiPageNotIncludeData(Page page) {
    UiPage uiPage = new UiPage<>();
    uiPage.setTotal(page.getTotal());
    uiPage.setPageSize(page.getSize());
    uiPage.setPages(page.getPages());
    uiPage.setPageNum(page.getCurrent());
    return uiPage;
}
### 类导入的包
com.baomidou.mybatisplus.plugins.Page
com.baomidou.mybatisplus.plugins.UiPage
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类TarCheckUtils中有一个名为isTarFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 通过读取压缩包头信息判断该文件是否为一个真正的tar类型包
     *
     * @param filePath
     * @return
     * @throws IOException
     */
public static boolean isTarFile(String filePath) throws IOException {
    try (InputStream is = new BufferedInputStream(new FileInputStream(filePath))) {
        byte[] header = new byte[TAR_MAGIC_OFFSET + TAR_MAGIC_SIZE];
        int count = is.read(header);
        if (count < header.length) {
            throw new IOException("Incomplete header read for file: " + filePath);
        }
        return isTar(header);
    } catch (IOException e) {
        throw new IOException("Error processing file: " + filePath, e);
    }
}
### 类导入的包
java.io.BufferedInputStream
java.io.FileInputStream
java.io.IOException
java.io.InputStream
### 类级别的变量
public static final int TAR_MAGIC_OFFSET = 257;
public static final byte[] TAR_MAGIC = new byte[] { 'u', 's', 't', 'a', 'r', '\0' };
public static final int TAR_MAGIC_SIZE = TAR_MAGIC.length;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类TarCheckUtils中有一个名为isTar的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static boolean isTar(byte[] header) {
    if (header.length < TAR_MAGIC_OFFSET + TAR_MAGIC_SIZE) {
        return false;
    }
    for (int i = 0; i < TAR_MAGIC_SIZE; i++) {
        if (header[TAR_MAGIC_OFFSET + i] != TAR_MAGIC[i]) {
            return false;
        }
    }
    return true;
}
### 类导入的包

### 类级别的变量
public static final int TAR_MAGIC_OFFSET = 257;
public static final byte[] TAR_MAGIC = new byte[] { 'u', 's', 't', 'a', 'r', '\0' };
public static final int TAR_MAGIC_SIZE = TAR_MAGIC.length;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类TarCheckUtils中有一个名为isTarGzFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 通过读取压缩包头信息判断该文件是否为一个真正的tar.gz类型包
     *
     * @param filePath
     * @return
     * @throws IOException
     */
public static boolean isTarGzFile(String filePath) throws IOException {
    byte[] header = new byte[2];
    try (InputStream inputStream = new FileInputStream(filePath)) {
        inputStream.read(header);
    }
    if (header[0] != (byte) 0x1F || header[1] != (byte) 0x8B) {
        return false;
    }
    //        try (GZIPInputStream gzipInputStream = new GZIPInputStream(new FileInputStream(filePath));
    //             TarArchiveInputStream tarArchiveInputStream = new TarArchiveInputStream(gzipInputStream)) {
    //            TarArchiveEntry tarEntry;
    //            while ((tarEntry = tarArchiveInputStream.getNextTarEntry()) != null) {
    //                if (!tarEntry.isDirectory() && tarEntry.getSize() != tarEntry.getRealSize()) {
    //                    return false;
    //                }
    //            }
    //        }
    return true;
}
### 类导入的包
java.io.FileInputStream
java.io.InputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UiTimeUtil中有一个名为modifyTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static long[] modifyTime(String modifyTime) {
    long[] dates = new long[2];
    if (modifyTime == null || "".equals(modifyTime)) {
        dates[0] = 0;
        dates[1] = System.currentTimeMillis();
    } else {
        String[] strs = modifyTime.split(",");
        String end = strs[1];
        dates[1] = getNextDayNoSplitAndToLong(end, 1);
        SimpleDateFormat dateformat = new SimpleDateFormat(DATE_FORMAT_SHORT);
        try {
            dates[0] = dateformat.parse(strs[0]).getTime();
        } catch (ParseException e) {
            logger.error(e.getMessage());
        }
    }
    return dates;
}
### 类导入的包
java.text.ParseException
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量
public static final String DATE_FORMAT_SHORT = "yyyyMMdd";
private static Logger logger = LoggerFactory.getLogger(UiTimeUtil.class);

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UiTimeUtil中有一个名为getNextDayNoSplitAndToLong的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static long getNextDayNoSplitAndToLong(String nowdate, int delay) {
    try {
        Date d = strToDateNoSpit(nowdate);
        long myTime = ((d.getTime() / 1000) + delay * 24 * 60 * 60) * 1000;
        return myTime;
    } catch (Exception e) {
        return 0L;
    }
}
### 类导入的包
java.util.Date
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UiTimeUtil中有一个名为strToDateNoSpit的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Date strToDateNoSpit(String strDate) {
    SimpleDateFormat formatter = new SimpleDateFormat(DATE_FORMAT_SHORT);
    ParsePosition pos = new ParsePosition(0);
    Date strtodate = formatter.parse(strDate, pos);
    return strtodate;
}
### 类导入的包
java.text.ParsePosition
java.text.SimpleDateFormat
java.util.Date
### 类级别的变量
public static final String DATE_FORMAT_SHORT = "yyyyMMdd";

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类Underline2Camel中有一个名为underline2Camel的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 下划线转驼峰法
     *
     * @param line       源字符串
     * @param smallCamel 大小驼峰,是否为小驼峰
     * @return 转换后的字符串
     */
public static String underline2Camel(String line, boolean smallCamel) {
    if (line == null || "".equals(line)) {
        return "";
    }
    StringBuffer sb = new StringBuffer();
    Pattern pattern = Pattern.compile("([A-Za-z\\d]+)(_)?");
    Matcher matcher = pattern.matcher(line);
    while (matcher.find()) {
        String word = matcher.group();
        sb.append(smallCamel && matcher.start() == 0 ? Character.toLowerCase(word.charAt(0)) : Character.toUpperCase(word.charAt(0)));
        int index = word.lastIndexOf('_');
        if (index > 0) {
            sb.append(word.substring(1, index).toLowerCase());
        } else {
            sb.append(word.substring(1).toLowerCase());
        }
    }
    return sb.toString();
}
### 类导入的包
java.util.regex.Matcher
java.util.regex.Pattern
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类Underline2Camel中有一个名为camel2Underline的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 驼峰法转下划线
     *
     * @param line 源字符串
     * @return 转换后的字符串
     */
public static String camel2Underline(String line, boolean isSmaill) {
    if (line == null || "".equals(line)) {
        return "";
    }
    line = String.valueOf(line.charAt(0)).toUpperCase().concat(line.substring(1));
    StringBuffer sb = new StringBuffer();
    Pattern pattern = Pattern.compile("[A-Z]([a-z\\d]+)?");
    Matcher matcher = pattern.matcher(line);
    while (matcher.find()) {
        String word = matcher.group();
        if (isSmaill)
            sb.append(word.toLowerCase());
        else
            sb.append(word.toUpperCase());
        sb.append(matcher.end() == line.length() ? "" : "_");
    }
    return sb.toString();
}
### 类导入的包
java.util.regex.Matcher
java.util.regex.Pattern
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类Underline2Camel中有一个名为main的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static void main(String[] args) {
    String line = "I_HAVE_AN_IPANG3_PIG";
    String camel = underline2Camel(line, true);
    System.out.println(camel);
    System.out.println(camel2Underline(camel, true));
}
### 类导入的包

### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UnitConvertUtils中有一个名为getSize的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 根据大小转换成对应单位
     *
     * @param size
     * @return
     */
public static String getSize(long size) {
    StringBuffer bytes = new StringBuffer();
    DecimalFormat format = new DecimalFormat("###");
    if (size >= 1024 * 1024 * 1024) {
        double i = (size / (1024.0 * 1024.0 * 1024.0));
        bytes.append(format.format(i)).append("GB");
    } else if (size >= 1024 * 1024) {
        double i = (size / (1024.0 * 1024.0));
        bytes.append(format.format(i)).append("MB");
    } else if (size >= 1024) {
        double i = (size / (1024.0));
        bytes.append(format.format(i)).append("KB");
    } else if (size < 1024) {
        if (size <= 0) {
            bytes.append("0B");
        } else {
            bytes.append((int) size).append("B");
        }
    }
    return bytes.toString();
}
### 类导入的包
java.text.DecimalFormat
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UnitConvertUtils中有一个名为cpuFormatToN的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Long cpuFormatToN(String number, String format) {
    if (StringUtils.isEmpty(number)) {
        return 0L;
    }
    if (StringUtils.isEmpty(format)) {
        return Long.parseLong(number) * 1000 * 1000000;
    }
    if ("m".equals(format)) {
        return Long.parseLong(number) * 1000000;
    }
    return Long.parseLong(number);
}
### 类导入的包
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UnitConvertUtils中有一个名为memFormatToMi的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Long memFormatToMi(String number, String format) {
    if (StringUtils.isEmpty(number)) {
        return 0L;
    }
    if ("Ti".equals(format) || "T".equals(format)) {
        return Long.parseLong(number) * 1024 * 1024;
    }
    if ("Gi".equals(format) || "G".equals(format)) {
        return Long.parseLong(number) * 1024;
    }
    if ("Ki".equals(format) || "K".equals(format)) {
        return Long.parseLong(number) / 1024;
    }
    return Long.parseLong(number);
}
### 类导入的包
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UnitConvertUtils中有一个名为cpuFormatToCore的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Long cpuFormatToCore(String number, String format) {
    if (StringUtils.isEmpty(number)) {
        return 0L;
    }
    if ("m".equals(format)) {
        return Long.parseLong(number) / 1000;
    }
    if ("n".equals(format)) {
        return Long.parseLong(number) / 1000 / 1000000;
    }
    return Long.parseLong(number);
}
### 类导入的包
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UnitConvertUtils中有一个名为memFormatToGi的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Long memFormatToGi(String number, String format) {
    if (StringUtils.isEmpty(number)) {
        return 0L;
    }
    if ("Ti".equals(format) || "T".equals(format)) {
        return Long.parseLong(number) * 1024;
    }
    if ("Gi".equals(format) || "G".equals(format)) {
        return Long.parseLong(number);
    }
    if ("Mi".equals(format) || "M".equals(format)) {
        return Long.parseLong(number) / 1024;
    }
    if ("Ki".equals(format) || "K".equals(format)) {
        return Long.parseLong(number) / 1024 / 1024;
    }
    return Long.parseLong(number) / 1024 / 1024 / 1024;
}
### 类导入的包
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类UnitConvertUtils中有一个名为gpuMemoryFormatToM的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static Long gpuMemoryFormatToM(String number, String format) {
    if (StringUtils.isEmpty(number)) {
        return 0L;
    }
    if ("k".equalsIgnoreCase(format)) {
        return Long.parseLong(number) * 1000;
    }
    return Long.parseLong(number);
}
### 类导入的包
org.apache.commons.lang3.StringUtils
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类VideoEncodeUtil中有一个名为VideoEncode的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 视频转码
     *
     * @param inputFile  输入文件路径
     * @param outputFile 输出文件路径
     */
public static void VideoEncode(String inputFile, String outputFile) {
    FFmpegFrameGrabber grabber = null;
    FFmpegFrameRecorder recorder = null;
    try {
        grabber = FFmpegFrameGrabber.createDefault(inputFile);
        grabber.start();
        // 获取音频通道数
        int audioChannels = grabber.getAudioChannels();
        recorder = new FFmpegFrameRecorder(outputFile, grabber.getImageWidth(), grabber.getImageHeight());
        // 设置视频编码器为H.264
        recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
        // 设置输出格式为MP4
        recorder.setFormat("mp4");
        // 设置帧率
        recorder.setFrameRate(grabber.getFrameRate());
        // 设置预设以加快编码速度（可能会牺牲质量）
        recorder.setVideoOption("preset", "fast");
        // 如果音频通道数大于0，则设置音频参数
        if (audioChannels > 0) {
            // 设置音频采样率
            recorder.setSampleRate(grabber.getSampleRate());
            // 设置音频编码器为AAC
            recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
            // 根据获取到的音频通道数设置
            recorder.setAudioChannels(audioChannels);
        }
        // 可以根据需要设置其他参数，如比特率、质量等
        // 设置恒定质量因子，值越低质量越好，文件越大;
        // 0：无损模式（实际上不会完全无损，但质量非常高）
        // 18-28：通常用于高质量的视频编码
        // 23：常被视作一个默认的平衡点，提供较好的视觉质量和合理的文件大小
        // 51：最差的质量
        recorder.setVideoOption("crf", "23");
        recorder.start();
        Frame frame;
        while ((frame = grabber.grab()) != null) {
            recorder.record(frame);
        }
        log.info("转码成功");
    } catch (FrameGrabber.Exception | FrameRecorder.Exception e) {
        log.error("视频转码失败", e);
    } finally {
        closeGrabber(grabber);
        closeRecorder(recorder);
    }
}
### 类导入的包
org.bytedeco.ffmpeg.global.avcodec
org.bytedeco.javacv.FFmpegFrameGrabber
org.bytedeco.javacv.FFmpegFrameRecorder
org.bytedeco.javacv.Frame
org.bytedeco.javacv.FrameGrabber
org.bytedeco.javacv.FrameRecorder
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类VideoEncodeUtil中有一个名为closeGrabber的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private static void closeGrabber(FFmpegFrameGrabber grabber) {
    if (grabber != null) {
        try {
            grabber.stop();
            grabber.close();
        } catch (FrameGrabber.Exception e) {
            log.error("关闭FFmpegFrameGrabber时出错", e);
        }
    }
}
### 类导入的包
org.bytedeco.javacv.FFmpegFrameGrabber
org.bytedeco.javacv.Frame
org.bytedeco.javacv.FrameGrabber
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类VideoEncodeUtil中有一个名为closeRecorder的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private static void closeRecorder(FFmpegFrameRecorder recorder) {
    if (recorder != null) {
        try {
            recorder.stop();
            recorder.close();
        } catch (FrameRecorder.Exception e) {
            log.error("关闭FFmpegFrameRecorder时出错", e);
        }
    }
}
### 类导入的包
org.bytedeco.javacv.FFmpegFrameRecorder
org.bytedeco.javacv.Frame
org.bytedeco.javacv.FrameRecorder
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类WebTermOutputStream中有一个名为write的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void write(byte[] b, int off, int len) throws IOException {
    if (b == null || b.length == 0 || len == 0 || ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0))) {
        return;
    }
    String response = new String(b, off, len, StandardCharsets.UTF_8);
    webSocketSession.sendMessage(new TextMessage(response));
}
### 类导入的包
org.springframework.web.socket.TextMessage
java.nio.charset.StandardCharsets
### 类级别的变量
private WebSocketSession webSocketSession;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类YamlUtil中有一个名为loadObject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static T loadObject(String templateString, Object context, Class<T> clz) throws Exception {
    log.debug("loadObject context:\n" + JSON.toJSONString(context));
    // 1、实例化模板对象
    Configuration cfg = new Configuration(Configuration.getVersion());
    //设置属性？ TBD
    cfg.setDefaultEncoding("UTF-8");
    // 2.创建模板加载器(字符模板加载器)
    StringTemplateLoader stringTemplateLoader = new StringTemplateLoader();
    stringTemplateLoader.putTemplate("template", templateString);
    // 3.设置模板加载器
    cfg.setTemplateLoader(stringTemplateLoader);
    Template template = cfg.getTemplate("template");
    try (StringWriter out = new StringWriter()) {
        // 将数据填充到模板中
        Yaml yaml = new Yaml();
        Map<String, Object> dataMap = yaml.load(JSON.toJSONString(context));
        template.process(dataMap, out);
        log.debug("生成yaml文件:\n" + out.toString());
        return yaml.loadAs(out.toString(), clz);
    } catch (Exception e) {
        log.error(e.getMessage());
        throw new Exception(String.format("生成yaml文件失败:%s", e.getMessage()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
freemarker.cache.StringTemplateLoader
freemarker.template.Configuration
freemarker.template.Template
org.yaml.snakeyaml.Yaml
java.io.StringWriter
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类YamlUtil中有一个名为loadK8sObject的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static T loadK8sObject(String yamlStr, String kind, Class<T> clz) throws Exception {
    log.debug("loadK8sObject yamlStr:\n" + yamlStr);
    try {
        // 将数据填充到模板中
        Yaml yaml = new Yaml();
        Iterable<Object> objects = yaml.loadAll(yamlStr);
        for (Object object : objects) {
            //LinkedHashMap转json
            JSONObject jsonObject = JSON.parseObject(JSONObject.toJSONString(object));
            if (Objects.equals(jsonObject.getString("kind"), kind)) {
                return yaml.loadAs(yaml.dump(object), clz);
            }
        }
        return null;
    } catch (Exception e) {
        log.error(e.getMessage());
        throw new Exception(String.format("生成yaml文件失败:%s", e.getMessage()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONObject
org.yaml.snakeyaml.Yaml
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类YamlUtil中有一个名为loadYaml的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public static String loadYaml(String templateString, String context) throws Exception {
    log.debug("loadObject context:\n" + JSON.toJSONString(context));
    // 1、实例化模板对象
    Configuration cfg = new Configuration(Configuration.getVersion());
    //设置属性？ TBD
    cfg.setDefaultEncoding("UTF-8");
    // 2.创建模板加载器(字符模板加载器)
    StringTemplateLoader stringTemplateLoader = new StringTemplateLoader();
    stringTemplateLoader.putTemplate("template", templateString);
    // 3.设置模板加载器
    cfg.setTemplateLoader(stringTemplateLoader);
    Template template = cfg.getTemplate("template");
    try (StringWriter out = new StringWriter()) {
        // 将数据填充到模板中
        Yaml yaml = new Yaml();
        Map<String, Object> dataMap = yaml.load(context);
        template.process(dataMap, out);
        log.debug("生成yaml文件:\n" + out);
        return out.toString();
    } catch (Exception e) {
        log.error(e.getMessage());
        throw new Exception(String.format("生成yaml文件失败:%s", e.getMessage()));
    }
}
### 类导入的包
com.alibaba.fastjson.JSON
freemarker.cache.StringTemplateLoader
freemarker.template.Configuration
freemarker.template.Template
org.yaml.snakeyaml.Yaml
java.io.StringWriter
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类YamlUtil中有一个名为test1的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private static void test1() throws Exception {
    String modelJsonString = "{\n" + "    \"devName\": \"csl\",\n" + "    \"imageId\": \"8\",\n" + "    \"trainingEnvironmentCus\": false,\n" + "    \"processUnitType\": \"CPU\",\n" + "    \"environmentId\": \"10000000\",\n" + "    \"creatorId\": 1,\n" + "    \"projectId\": \"1\",\n" + "    \"core\": \"1\",\n" + "    \"memorySize\": \"1G\",\n" + "    \"gpuSize\": 0,\n" + "    \"extendData\": {\n" + "        \"core\": \"2\",\n" + "        \"memorySize\": \"2G\"\n" + "    }\n" + "}";
    String templateString = "apiVersion: v1\n" + "kind: Service\n" + "metadata:\n" + "  name: jupyter-algorithm-${devName}\n" + "spec:\n" + "  ports:\n" + "  - name: http\n" + "    targetPort: http\n" + "    port: #{containerPort?default(8888)}\n" + "    protocol: TCP\n" + "  selector:\n" + "    app: jupyter-algorithm-${devName}\n" + "  type: NodePort";
    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
    Class<?> serviceClass = classLoader.loadClass("io.kubernetes.client.openapi.models.V1Service");
    Class<?> modelClass = classLoader.loadClass("com.eshore.gdai.trainingcenter.entity.GdaiDevModel");
    //        Object model = JSON.parseObject(modelJsonString, modelClass);
    //        Object object = YamlUtil.loadObject(templateString, model, serviceClass);
    //        System.out.println("转换对象：\n" + io.kubernetes.client.util.Yaml.dump(object));
    String yaml = YamlUtil.loadYaml(templateString, modelJsonString);
    System.out.println(yaml);
}
### 类导入的包
com.alibaba.fastjson.JSON
org.yaml.snakeyaml.Yaml
java.util
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类YamlUtil中有一个名为test2的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
private static void test2() throws Exception {
    StringBuilder sb = new StringBuilder();
    Map<String, Object> dataMap = new HashMap<String, Object>();
    sb.append("字符串: \n");
    //字符串
    sb.append(" 字符串->字符串: ").append("${str1}").append("\n");
    dataMap.put("str1", "20231008001");
    sb.append(" 数字->字符串: ").append("${str2}").append("\n");
    dataMap.put("str2", 20231008001L);
    sb.append(" 数字->字符串-直接输出: ").append("${str3?c}").append("\n");
    dataMap.put("str3", 20231008001L);
    sb.append("数字: \n");
    //数字
    sb.append(" 数字->数字: ").append("#{num1}").append("\n");
    dataMap.put("num1", 20231008001L);
    sb.append(" 浮点数字->数字: ").append("#{num2}").append("\n");
    dataMap.put("num2", 444444.3344);
    sb.append(" 大浮点数字->数字: ").append("#{num3}").append("\n");
    dataMap.put("num3", 20231008001.33);
    sb.append(" 字符串->数字: ").append("#{num4?number}").append("\n");
    dataMap.put("num4", "20231008001");
    sb.append("集合: \n");
    //集合 extendData
    sb.append(" 集合map->字符串: ").append("${extendData.cpu}").append("\n");
    Map<String, Object> extendData = new HashMap<String, Object>();
    extendData.put("cpu", 20231008001L);
    dataMap.put("extendData", extendData);
    //集合 list
    sb.append("volumes:").append("\n");
    sb.append("<#list volumes as volume>").append("\n");
    sb.append(" - hostPath:").append("\n");
    sb.append("    type: Directory").append("\n");
    sb.append("    path: ${volume.basePath}${volume.filePath}").append("\n");
    sb.append("   name: volume-${volume_index}").append("\n");
    sb.append("</#list>").append("\n");
    Map<String, Object> volume1 = new HashMap<String, Object>();
    volume1.put("basePath", "/cephfs/algorithm/fileManager");
    volume1.put("filePath", "/app");
    Map<String, Object> volume2 = new HashMap<String, Object>();
    volume2.put("basePath", "/cephfs/algorithm/fileManager");
    volume2.put("filePath", "/result");
    List<Map<String, Object>> volumes = new ArrayList<>();
    volumes.add(volume1);
    volumes.add(volume2);
    dataMap.put("volumes", volumes);
    sb.append("services-ports:").append("\n");
    sb.append("<#list ports as port>").append("\n");
    sb.append(" - name: ").append("http-${port.port}").append("\n");
    sb.append("   port: ").append("${port.port}").append("\n");
    sb.append("   targetPort: ").append("http-${port.port}").append("\n");
    sb.append("   protocol: TCP").append("\n");
    sb.append("</#list>").append("\n");
    sb.append("ports:").append("\n");
    sb.append("<#list ports as port>").append("\n");
    sb.append(" - name: ").append("http-${port.port}").append("\n");
    sb.append("   containerPort: ").append("${port.port}").append("\n");
    sb.append("   protocol: TCP").append("\n");
    sb.append("</#list>").append("\n");
    Map<String, Object> port1 = new HashMap<String, Object>();
    port1.put("port", "8080");
    Map<String, Object> port2 = new HashMap<String, Object>();
    port2.put("port", "8989");
    List<Map<String, Object>> ports = new ArrayList<>();
    ports.add(port1);
    ports.add(port2);
    dataMap.put("ports", ports);
    //遍历map
    sb.append("env:").append("\n");
    sb.append("<#list env?keys as key>").append("\n");
    sb.append(" - name: ${key}").append("\n");
    sb.append("   value: ${env[\"${key}\"]}").append("\n");
    sb.append("</#list>").append("\n");
    Map<String, Object> env = new HashMap<String, Object>();
    env.put("vvmemory", "1");
    env.put("PYTHONUNBUFFERED", 1);
    dataMap.put("env", env);
    sb.append("services-ports:").append("\n");
    sb.append("<#list portList as port>").append("\n");
    sb.append(" - name: ").append("http-${port}").append("\n");
    sb.append("   port: ").append("${port}").append("\n");
    sb.append("   targetPort: ").append("http-${port}").append("\n");
    sb.append("   protocol: TCP").append("\n");
    sb.append("</#list>").append("\n");
    List<Integer> portList = new ArrayList<>();
    portList.add(1);
    portList.add(2);
    portList.add(3);
    JSONArray jsonArray = new JSONArray();
    jsonArray.addAll(portList);
    dataMap.put("portList", jsonArray);
    //默认值
    sb.append("默认值1: ").append("${empty?default('default value')}").append("\n");
    sb.append("默认值2: ").append("${empty!'default value'}").append("\n");
    //判断空
    sb.append("<#if volumes??>").append("\n");
    sb.append("判断非空: ").append("${volumes?size}").append("\n");
    sb.append("</#if>").append("\n");
    //?    用于使用内建函数
    sb.append("时间: ").append("${'2023-11-11'?date}").append("\n");
    sb.append("大写: ").append("${'abc'?upper_case}").append("\n");
    //
    String cmd = "     cd /home/app\n     ./start.sh\n     tailf ../log/app.log";
    sb.append("command:").append("\n");
    sb.append(" - /bin/bash").append("\n");
    sb.append(" - '-c'").append("\n");
    sb.append(" - >").append("\n");
    sb.append(cmd).append("\n");
    String templateContent = sb.toString();
    Object object = YamlUtil.loadObject(templateContent, dataMap, Object.class);
    System.out.println("转换对象：\n" + io.kubernetes.client.util.Yaml.dump(object));
}
### 类导入的包
com.alibaba.fastjson.JSON
com.alibaba.fastjson.JSONArray
org.yaml.snakeyaml.Yaml
java.util
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为unZip的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * zip解压
     *
     * @param srcFile     zip源文件
     * @param destDirPath 解压后的目标文件夹
     * @throws RuntimeException 解压失败会抛出运行时异常
     */
public static List<String> unZip(File srcFile, String destDirPath) throws RuntimeException {
    //记录解压出来的所有文件名
    List<String> filesName = new ArrayList<>();
    long start = System.currentTimeMillis();
    // 判断源文件是否存在
    if (!srcFile.exists()) {
        throw new RuntimeException(srcFile.getPath() + "所指文件不存在");
    }
    // 开始解压
    ZipFile zipFile = null;
    try {
        zipFile = new ZipFile(srcFile, Charset.forName("GBK"));
        Enumeration<?> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = (ZipEntry) entries.nextElement();
            //添加进filesName
            filesName.add(entry.getName());
            //log.info("解压文件:" + entry.getName());
            // 如果是文件夹，就创建个文件夹
            if (entry.isDirectory()) {
                String dirPath = destDirPath + "/" + entry.getName();
                File dir = FileUtils.getFile(dirPath);
                dir.mkdirs();
            } else {
                // 如果是文件，就先创建一个文件，然后用io流把内容copy过去
                File targetFile = FileUtils.getFile(destDirPath + "/" + entry.getName());
                // 保证这个文件的父文件夹必须要存在
                if (!targetFile.getParentFile().exists()) {
                    targetFile.getParentFile().mkdirs();
                }
                targetFile.createNewFile();
                // 将压缩文件内容写入到这个文件中
                zipWriteToFile(zipFile, entry, targetFile);
            }
        }
        long end = System.currentTimeMillis();
        log.info("解压完成，耗时：" + (end - start) + " ms");
    } catch (Exception e) {
        log.info("解压异常：", e);
        throw new RuntimeException("unzip error from ZipUtils", e);
    } finally {
        if (zipFile != null) {
            try {
                zipFile.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return filesName;
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.File
java.io.IOException
java.nio.charset.Charset
java.nio.file.Path
java.util.ArrayList
java.util.Enumeration
java.util.List
java.util.zip.ZipEntry
java.util.zip.ZipFile
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为deleteFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 删除临时文件及目录
     *
     * @param file
     */
public static void deleteFile(File file) {
    //判断文件不为null或文件目录存在
    if (file == null || !file.exists()) {
        return;
    }
    //取得这个目录下的所有子文件对象
    File[] files = file.listFiles();
    //遍历该目录下的文件对象
    for (File f : files) {
        //打印文件名
        //String name = file.getName();
        //logger.info(name);
        //判断子目录是否存在子目录,如果是文件则删除
        if (f.isDirectory()) {
            deleteFile(f);
        } else {
            f.delete();
        }
    }
    //删除空文件夹 for循环已经把上一层节点的目录清空。
    file.delete();
    return;
}
### 类导入的包
java.io.File
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为toZip的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 文件压缩
     *
     * @param sourceDirectory
     * @param out
     * @param compression
     * @param keepDirStructure
     * @throws RuntimeException
     */
public static void toZip(String sourceDirectory, OutputStream out, boolean compression, boolean keepDirStructure) {
    long start = System.currentTimeMillis();
    try (ZipOutputStream zipOut = new ZipOutputStream(out);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(zipOut)) {
        File sourceFile = FileUtils.getFile(sourceDirectory);
        compress(sourceFile, zipOut, sourceFile.getName(), compression, keepDirStructure, bufferedOutputStream);
        long end = System.currentTimeMillis();
        log.info("压缩完成，耗时：" + (end - start) + " ms");
    } catch (Exception e) {
        log.info("算法结果压缩异常", e);
    }
}
### 类导入的包
org.apache.commons.io.FileUtils
java.io.BufferedOutputStream
java.io.File
java.io.OutputStream
java.util.zip.ZipOutputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为compress的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 递归压缩方法
     *
     * @param sourceFile           源文件
     * @param zipOut               压缩后的名称
     * @param name                 zip输出流
     * @param compression          是否压缩文件
     *                             true：
     *                             false：仅复制文件到ZIP包
     * @param keepDirStructure     是否保留原目录结构
     *                             true：保留目录结构
     *                             false：不保留(注意：不保留目录结构可能会出现同名文件,会导致压缩失败)
     * @param bufferedOutputStream
     * @throws Exception
     */
private static void compress(File sourceFile, ZipOutputStream zipOut, String name, boolean compression, boolean keepDirStructure, BufferedOutputStream bufferedOutputStream) throws Exception {
    //单文件，直接压缩
    if (sourceFile.isFile()) {
        try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(sourceFile))) {
            if (compression) {
                zipOut.putNextEntry(new ZipEntry(name));
            } else {
                ZipEntry entry = new ZipEntry(name);
                //核心，和复制粘贴效果一样，并没有压缩，但速度很快
                entry.setMethod(ZipEntry.STORED);
                entry.setSize(sourceFile.length());
                entry.setCrc(getFileCRCCode(sourceFile));
                zipOut.putNextEntry(entry);
            }
            int len = 0;
            byte[] data = new byte[8192];
            while ((len = bufferedInputStream.read(data)) != -1) {
                bufferedOutputStream.write(data, 0, len);
            }
            bufferedInputStream.close();
            bufferedOutputStream.flush();
        }
    } else {
        //目录或多文件
        File[] listFiles = sourceFile.listFiles();
        //目录复制
        if (listFiles == null || listFiles.length == 0) {
            // 需要保留原来的文件结构时,需要对空文件夹进行处理
            if (keepDirStructure) {
                // 空文件夹的处理
                zipOut.putNextEntry(new ZipEntry(name + "/"));
                // 没有文件，不需要文件的copy
                zipOut.closeEntry();
            }
        } else {
            for (File file : listFiles) {
                // 判断是否需要保留原来的文件结构
                if (keepDirStructure) {
                    // 注意：file.getName()前面需要带上父文件夹的名字加一斜杠,
                    // 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
                    compress(file, zipOut, name + "/" + file.getName(), compression, keepDirStructure, bufferedOutputStream);
                } else {
                    compress(file, zipOut, file.getName(), compression, keepDirStructure, bufferedOutputStream);
                }
            }
        }
    }
}
### 类导入的包
java.io.BufferedInputStream
java.io.File
java.io.FileInputStream
java.io.InputStream
java.io.OutputStream
java.util.zip.ZipEntry
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为getFileCRCCode的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取CRC32
     *
     * @param file
     * @return
     * @throws Exception
     */
public static long getFileCRCCode(File file) {
    FileInputStream fileInputStream = null;
    BufferedInputStream bufferedInputStream = null;
    CRC32 crc32 = null;
    CheckedInputStream checkedinputstream = null;
    try {
        fileInputStream = new FileInputStream(file);
        bufferedInputStream = new BufferedInputStream(fileInputStream);
        crc32 = new CRC32();
        //CheckedInputStream一种输入流，它还维护正在读取的数据的校验和。 然后可以使用校验和来验证输入数据的完整性。
        checkedinputstream = new CheckedInputStream(bufferedInputStream, crc32);
        while (checkedinputstream.read() != -1) {
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (checkedinputstream != null) {
                checkedinputstream.close();
            }
            if (bufferedInputStream != null) {
                bufferedInputStream.close();
            }
            if (fileInputStream != null) {
                fileInputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if (crc32 == null) {
        return 0;
    } else {
        return crc32.getValue();
    }
}
### 类导入的包
java.io.BufferedInputStream
java.io.File
java.io.FileInputStream
java.io.IOException
java.io.InputStream
java.util.zip.CRC32
java.util.zip.CheckedInputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为readZip的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * @param filePath    压缩文件目录及名称
     * @param destDirPath 读取压缩文件之后另存为临时目录
     * @param uploadPath  压缩文件存放目录
     * @return
     */
public static Set<String> readZip(String filePath, String destDirPath, String uploadPath) {
    Set<String> set = new HashSet<>();
    try (net.lingala.zip4j.ZipFile zipFile = new net.lingala.zip4j.ZipFile(filePath.replace("\\\\", "/"))) {
        // 字符集设置为GBK，避免中文名乱码
        zipFile.setCharset(Charset.forName("GBK"));
        if (!zipFile.isValidZipFile()) {
            return null;
        }
        // 获取所有的文件(FileHeader包括了文件夹、子文件夹、文件)
        List<FileHeader> fileHeaderList = zipFile.getFileHeaders();
        // 遍历其中的文件
        for (FileHeader fileHeader : fileHeaderList) {
            //读取压缩文件中文件相对路径及文件名称
            String fileName = fileHeader.getFileName();
            //拼装得到所读取文件的全路径
            String tempName = uploadPath + "/" + fileName;
            //判断路径中是否包含“__MACOSX“，如果包含全部跳过
            if (!fileName.contains("__MACOSX")) {
                if (fileHeader.isDirectory()) {
                    //存储该路径到set集合便于之后遍历解析
                    set.add(destDirPath + "/" + fileName);
                    if (FileUtils.getFile(tempName).isFile()) {
                        ZipInputStream inputStream = zipFile.getInputStream(fileHeader);
                        // 通过commons-io的工具包将流转为文件存储来测试
                        FileUtils.copyInputStreamToFile(inputStream, FileUtils.getFile(destDirPath + "/" + fileName));
                    }
                } else {
                    set.add(destDirPath);
                    ZipInputStream inputStream = zipFile.getInputStream(fileHeader);
                    // 通过commons-io的工具包将流转为文件存储来测试
                    FileUtils.copyInputStreamToFile(inputStream, FileUtils.getFile(destDirPath + "/" + fileName));
                }
            }
        }
    } catch (IOException e) {
        log.error(e.getMessage(), e);
    }
    return set;
}
### 类导入的包
net.lingala.zip4j.io.inputstream.ZipInputStream
net.lingala.zip4j.model.FileHeader
org.apache.commons.io.FileUtils
java.io.File
java.io.IOException
java.io.InputStream
java.nio.charset.Charset
java.nio.file.Path
java.util.HashSet
java.util.List
java.util.Set
java.util.zip.ZipFile
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为zipWriteToFile的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 将压缩文件内容写入到这个文件中
     *
     * @param zipFile
     * @param entry
     * @param targetFile
     */
public static void zipWriteToFile(ZipFile zipFile, ZipEntry entry, File targetFile) {
    InputStream is = null;
    FileOutputStream fos = null;
    try {
        is = zipFile.getInputStream(entry);
        fos = new FileOutputStream(targetFile);
        int len;
        byte[] buf = new byte[1024];
        while ((len = is.read(buf)) != -1) {
            fos.write(buf, 0, len);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (fos != null) {
                fos.close();
            }
            if (is != null) {
                IOUtils.closeQuietly(is);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
### 类导入的包
org.apache.commons.compress.utils.IOUtils
java.io.File
java.io.FileOutputStream
java.io.IOException
java.io.InputStream
java.io.OutputStream
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.util下的类ZipUtil中有一个名为getRootDirectoriesWithinZip的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 获取压缩包最顶层目录
     *
     * @param zipFile
     * @return
     * @throws Exception
     */
public static List<String> getRootDirectoriesWithinZip(String zipFile) {
    Set<String> set = new LinkedHashSet();
    try (java.util.zip.ZipInputStream zipInputStream = new java.util.zip.ZipInputStream(new FileInputStream(zipFile))) {
        ZipEntry zipEntry = zipInputStream.getNextEntry();
        while (zipEntry != null) {
            String fileName = zipEntry.getName();
            //Path path = Paths.get(fileName);
            //Path path = FileSystems.getDefault().getPath(fileName);
            File file = FileUtils.getFile(fileName);
            Path path = file.toPath();
            int nameCount = path.getNameCount();
            for (int i = 0; i < nameCount; i++) {
                if (path != null && path.getParent() != null) {
                    path = path.getParent();
                }
            }
            set.add(path.toString());
            zipEntry = zipInputStream.getNextEntry();
        }
        List<String> retList = new ArrayList<>();
        retList.addAll(set);
        return retList;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
### 类导入的包
net.lingala.zip4j.io.inputstream.ZipInputStream
org.apache.commons.io.FileUtils
java.io.File
java.io.FileInputStream
java.io.InputStream
java.nio.file.Path
java.util.ArrayList
java.util.HashSet
java.util.LinkedHashSet
java.util.List
java.util.Set
java.util.zip.ZipEntry
### 类级别的变量


你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类BaseQueryVo中有一个名为getOrderColumn的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public String getOrderColumn() {
    if (null == orderColumn || "".equals(orderColumn)) {
        return "update_time";
    }
    orderColumn = Underline2Camel.camel2Underline(orderColumn, true);
    return orderColumn;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.Underline2Camel
### 类级别的变量
private String orderColumn;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类BaseQueryVo中有一个名为isAsc的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public boolean isAsc() {
    boolean isAsc = false;
    if (ASC.equals(sort)) {
        isAsc = true;
    } else if (DESC.equals(sort)) {
        isAsc = false;
    }
    return isAsc;
}
### 类导入的包

### 类级别的变量
public final static String ASC = "ascend";
public final static String DESC = "descend";
private String sort;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类BaseQueryVo中有一个名为getStartTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Long getStartTime() {
    if (sTime != null) {
        return sTime;
    }
    long[] dateTimes = UiTimeUtil.modifyTime(updateTime);
    sTime = dateTimes[0];
    eTime = dateTimes[1];
    return sTime;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.UiTimeUtil
### 类级别的变量
private String updateTime = "";
@JsonIgnore
private Long sTime;
@JsonIgnore
private Long eTime;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类BaseQueryVo中有一个名为getEndTime的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public Long getEndTime() {
    if (eTime != null) {
        return eTime;
    }
    long[] dateTimes = UiTimeUtil.modifyTime(updateTime);
    sTime = dateTimes[0];
    eTime = dateTimes[1];
    return eTime;
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.UiTimeUtil
### 类级别的变量
private String updateTime = "";
@JsonIgnore
private Long sTime;
@JsonIgnore
private Long eTime;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类FileInfo中有一个名为equals的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public boolean equals(Object o) {
    if (o == this) {
        return true;
    } else if (!(o instanceof FileInfo)) {
        return false;
    } else {
        FileInfo other = (FileInfo) o;
        if (!other.canEqual(this)) {
            return false;
        } else {
            label63: {
                Object this$hash = this.getHash();
                Object other$hash = other.getHash();
                if (this$hash == null) {
                    if (other$hash == null) {
                        break label63;
                    }
                } else if (this$hash.equals(other$hash)) {
                    break label63;
                }
                return false;
            }
            Object this$name = this.getName();
            Object other$name = other.getName();
            if (this$name == null) {
                if (other$name != null) {
                    return false;
                }
            } else if (!this$name.equals(other$name)) {
                return false;
            }
            Object this$type = this.getType();
            Object other$type = other.getType();
            if (this$type == null) {
                if (other$type != null) {
                    return false;
                }
            } else if (!this$type.equals(other$type)) {
                return false;
            }
            label42: {
                Object this$path = this.getPath();
                Object other$path = other.getPath();
                if (this$path == null) {
                    if (other$path == null) {
                        break label42;
                    }
                } else if (this$path.equals(other$path)) {
                    break label42;
                }
                return false;
            }
            if (this.getCreateTime() != other.getCreateTime()) {
                return false;
            } else {
                return true;
            }
        }
    }
}
### 类导入的包

### 类级别的变量
@ApiModelProperty(value = "文件的哈希值,或者MD5值", required = true)
private String hash;
@ApiModelProperty(value = "文件的名称", required = true)
private String name;
@ApiModelProperty(value = "文件类型", required = true)
private String type;
@ApiModelProperty(value = "文件上传路径", required = true)
private String path;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类FileInfo中有一个名为hashCode的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public int hashCode() {
    boolean PRIME = true;
    int result = 1;
    Object $hash = this.getHash();
    result = result * 59 + ($hash == null ? 43 : $hash.hashCode());
    Object $name = this.getName();
    result = result * 59 + ($name == null ? 43 : $name.hashCode());
    Object $type = this.getType();
    result = result * 59 + ($type == null ? 43 : $type.hashCode());
    Object $path = this.getPath();
    result = result * 59 + ($path == null ? 43 : $path.hashCode());
    long $createTime = this.getCreateTime();
    result = result * 59 + (int) ($createTime >>> 32 ^ $createTime);
    return result;
}
### 类导入的包

### 类级别的变量
@ApiModelProperty(value = "文件的哈希值,或者MD5值", required = true)
private String hash;
@ApiModelProperty(value = "文件的名称", required = true)
private String name;
@ApiModelProperty(value = "文件类型", required = true)
private String type;
@ApiModelProperty(value = "文件上传路径", required = true)
private String path;
@ApiModelProperty(value = "文件创建时间", example = "0", required = true)
private long createTime;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类UploadFileParam中有一个名为equals的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public boolean equals(Object o) {
    if (o == this) {
        return true;
    } else if (!(o instanceof UploadFileParam)) {
        return false;
    } else {
        UploadFileParam other = (UploadFileParam) o;
        if (!other.canEqual(this)) {
            return false;
        } else {
            label71: {
                Object this$id = this.getId();
                Object other$id = other.getId();
                if (this$id == null) {
                    if (other$id == null) {
                        break label71;
                    }
                } else if (this$id.equals(other$id)) {
                    break label71;
                }
                return false;
            }
            if (this.getChunks() != other.getChunks()) {
                return false;
            } else if (this.getChunk() != other.getChunk()) {
                return false;
            } else if (this.getSize() != other.getSize()) {
                return false;
            } else {
                Object this$name = this.getName();
                Object other$name = other.getName();
                if (this$name == null) {
                    if (other$name != null) {
                        return false;
                    }
                } else if (!this$name.equals(other$name)) {
                    return false;
                }
                Object this$file = this.getFile();
                Object other$file = other.getFile();
                if (this$file == null) {
                    if (other$file != null) {
                        return false;
                    }
                } else if (!this$file.equals(other$file)) {
                    return false;
                }
                Object this$md5 = this.getMd5();
                Object other$md5 = other.getMd5();
                if (this$md5 == null) {
                    if (other$md5 != null) {
                        return false;
                    }
                } else if (!this$md5.equals(other$md5)) {
                    return false;
                }
                return true;
            }
        }
    }
}
### 类导入的包

### 类级别的变量
@ApiModelProperty(value = "任务ID", required = true)
private String id;
@ApiModelProperty(value = "当前文件名称", required = true)
private String name;
@ApiModelProperty(value = "当前文件的分片对象", required = true)
private MultipartFile file;
@ApiModelProperty(value = "当前文件的MD5,不是分片的", required = true)
private String md5;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo下的类UploadFileParam中有一个名为hashCode的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public int hashCode() {
    boolean PRIME = true;
    int result = 1;
    Object $id = this.getId();
    result = result * 59 + ($id == null ? 43 : $id.hashCode());
    result = result * 59 + this.getChunks();
    result = result * 59 + this.getChunk();
    long $size = this.getSize();
    result = result * 59 + (int) ($size >>> 32 ^ $size);
    Object $name = this.getName();
    result = result * 59 + ($name == null ? 43 : $name.hashCode());
    Object $file = this.getFile();
    result = result * 59 + ($file == null ? 43 : $file.hashCode());
    Object $md5 = this.getMd5();
    result = result * 59 + ($md5 == null ? 43 : $md5.hashCode());
    return result;
}
### 类导入的包

### 类级别的变量
@ApiModelProperty(value = "任务ID", required = true)
private String id;
@ApiModelProperty(value = "当前分片大小", example = "0", required = true)
private long size = 0L;
@ApiModelProperty(value = "当前文件名称", required = true)
private String name;
@ApiModelProperty(value = "当前文件的分片对象", required = true)
private MultipartFile file;
@ApiModelProperty(value = "当前文件的MD5,不是分片的", required = true)
private String md5;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo.pod下的类MetricsVo中有一个名为calculationPercent的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
public void calculationPercent() {
    if (StringUtils.isNotEmpty(cpuRequestNumber) && StringUtils.isNotEmpty(cpuUsageNumber)) {
        cpuUsagePercent = (Float.valueOf(UnitConvertUtils.cpuFormatToN(cpuUsageNumber, cpuUsageFormat)) / Float.valueOf(UnitConvertUtils.cpuFormatToN(cpuRequestNumber, cpuRequestFormat)) * 100);
    }
    if (StringUtils.isNotEmpty(memoryRequestNumber) && StringUtils.isNotEmpty(memoryUsageNumber)) {
        memoryUsagePercent = (Float.valueOf((UnitConvertUtils.memFormatToMi(memoryUsageNumber, memoryUsageFormat)) / Float.valueOf(UnitConvertUtils.memFormatToMi(memoryRequestNumber, memoryRequestFormat))) * 100);
    }
}
### 类导入的包
com.eshore.gdai.trainingcenter.util.UnitConvertUtils
org.apache.commons.lang3.StringUtils
### 类级别的变量
/**
 * cpu 申请量
 */
private String cpuRequestNumber;
/**
 * cpu用量
 */
private String cpuUsageNumber;
/**
 * cpu 申请量 单位 1核=1000m,1m=1000000n
 */
private String cpuRequestFormat;
/**
 * cpu用量 单位 1核=1000m,1m=1000000n
 */
private String cpuUsageFormat;
/**
 * cpu 使用百分比
 */
private Float cpuUsagePercent;
/**
 * 内存申请量
 */
private String memoryRequestNumber;
/**
 * 内存用量
 */
private String memoryUsageNumber;
/**
 * 内存申请量单位
 */
private String memoryRequestFormat;
/**
 * 内存用量单位
 */
private String memoryUsageFormat;
/**
 * 内存使用百分比
 */
private Float memoryUsagePercent;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo.pod下的类TerminalWsConnection中有一个名为run的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 线程任务
     */
public void run() {
    List<String> commands = Arrays.asList("/bin/bash", "/bin/sh");
    for (String command : commands) {
        boolean shellResult = this.startProcess(command);
        if (shellResult) {
            break;
        }
    }
    LOGGER.info("session closed. exit thread");
    // SpringWebSocketHandler.TerminalWsConnections.remove(this.webSocketSession.getId());
}
### 类导入的包
java.util.Arrays
java.util.List
### 类级别的变量
private static final Logger LOGGER = LoggerFactory.getLogger(ShellWebSocketHandler.class);
private WebSocketSession webSocketSession;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo.pod下的类TerminalWsConnection中有一个名为startProcess的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 连接 k8s 在指定 pod 容器中执行命令
     *
     * @param command
     */
private boolean startProcess(String command) {
    LOGGER.info("k8s exec {}", command);
    String namespace = this.getPod().getNamespace();
    String name = this.getPod().getName();
    String container = this.getPod().getContainer();
    String cmd = this.getPod().getCommand();
    boolean shellResult = false;
    try {
        proc = this.exec.exec(namespace, name, new String[] { command }, container, true, true);
        if (StringUtils.isNotEmpty(cmd)) {
            cmd = new String(Base64.getDecoder().decode(cmd), StandardCharsets.UTF_8);
            try (InputStream inputStream = new ByteArrayInputStream(cmd.getBytes())) {
                Streams.copy(inputStream, proc.getOutputStream());
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    } catch (Exception e) {
        String msg = "k8s client exec cmd error: " + e.getMessage();
        LOGGER.error(msg);
        TextMessage textMessage = new TextMessage(msg.getBytes(StandardCharsets.UTF_8));
        try {
            this.webSocketSession.sendMessage(textMessage);
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        return true;
    }
    try {
        while (true) {
            byte[] data = new byte[1024];
            if (this.proc.getInputStream().read(data) != -1) {
                TextMessage textMessage = new TextMessage(data);
                if (isInValidBash(textMessage, command)) {
                    this.webSocketSession.sendMessage(textMessage);
                    break;
                } else {
                    shellResult = true;
                }
                this.webSocketSession.sendMessage(textMessage);
            }
        }
    } catch (IOException e) {
        LOGGER.warn("inputStream Pipe has closed.");
    } finally {
        this.exit();
    }
    return shellResult;
}
### 类导入的包
io.kubernetes.client.util.Streams
org.apache.commons.lang.StringUtils
org.springframework.web.socket.TextMessage
java.io.ByteArrayInputStream
java.io.IOException
java.io.InputStream
java.nio.charset.StandardCharsets
java.util.Base64
### 类级别的变量
private static final Logger LOGGER = LoggerFactory.getLogger(ShellWebSocketHandler.class);
public Process proc;
private Exec exec;
private WebSocketSession webSocketSession;

你是一名专业的Java开发工程师，现在有一个基于Spring boot框架编写的web后端服务项目，其中在包com.eshore.gdai.trainingcenter.vo.pod下的类TerminalWsConnection中有一个名为isInValidBash的方法，你要仔细阅读这个方法的代码实现，为这个方法编写详细的注释，包括但不限于这个方法的意图和作用、代码执行的逻辑等，严禁虚构不存在的信息；输出时严格按javadoc的格式输出注释的内容，严谨输出注释外的任何无关文本或解释；下面是关于这个方法的详细代码和与之相关联的上下文信息
### 方法定义
/**
     * 验证命令执行结果
     *
     * @param textMessage
     * @param command
     * @return
     */
private boolean isInValidBash(TextMessage textMessage, String command) {
    String failMessage = "exec failed";
    if (textMessage.getPayload().trim().contains(failMessage)) {
        LOGGER.warn("oci runtime error: exec failed: {}", command);
        return true;
    } else {
        return false;
    }
}
### 类导入的包

### 类级别的变量
private static final Logger LOGGER = LoggerFactory.getLogger(ShellWebSocketHandler.class);
private Exec exec;