//package com.qqchen.deploy.backend.service.impl;
//
//import com.qqchen.deploy.backend.common.service.impl.BaseServiceImpl;
//import com.qqchen.deploy.backend.entity.JenkinsConfig;
//import com.qqchen.deploy.backend.repository.IJenkinsBuildRepository;
//import com.qqchen.deploy.backend.repository.IJenkinsConfigRepository;
//import com.qqchen.deploy.backend.repository.IJenkinsJobRepository;
//import com.qqchen.deploy.backend.repository.IJenkinsSyncHistoryRepository;
//import com.qqchen.deploy.backend.repository.IJenkinsViewRepository;
//import com.qqchen.deploy.backend.service.IJenkinsService;
//import jakarta.persistence.EntityManager;
//import jakarta.persistence.PersistenceContext;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.boot.web.client.RestTemplateBuilder;
//import org.springframework.core.ParameterizedTypeReference;
//import org.springframework.http.HttpEntity;
//import org.springframework.http.HttpHeaders;
//import org.springframework.http.HttpMethod;
//import org.springframework.http.HttpStatus;
//import org.springframework.http.MediaType;
//import org.springframework.http.ResponseEntity;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//import org.springframework.web.client.RestTemplate;
//
//import java.time.Duration;
//import java.time.Instant;
//import java.time.LocalDateTime;
//import java.time.ZoneId;
//import java.util.ArrayList;
//import java.util.Base64;
//import java.util.Collections;
//import java.util.List;
//import java.util.Map;
//import java.util.concurrent.CompletableFuture;
//import java.util.concurrent.ConcurrentHashMap;
//import java.util.stream.Collectors;
//
//@Slf4j
//@Service
//public class IJenkinsServiceImpl extends BaseServiceImpl<JenkinsConfig, Long> implements IJenkinsService {
//
//    private final IJenkinsConfigRepository jenkinsConfigRepository;
//    private final IJenkinsSyncHistoryRepository jenkinsSyncHistoryRepository;
//    private final IJenkinsViewRepository jenkinsViewRepository;
//    private final IJenkinsJobRepository jenkinsJobRepository;
//    private final IJenkinsBuildRepository jenkinsBuildRepository;
//
//    @PersistenceContext
//    private EntityManager entityManager;
//
//    // 使用 ConcurrentHashMap 记录正在执行的任务
//    private static final Map<Long, Boolean> RUNNING_TASKS = new ConcurrentHashMap<>();
//
//    @Autowired
//    public IJenkinsServiceImpl(
//        IJenkinsConfigRepository jenkinsConfigRepository,
//        IJenkinsSyncHistoryRepository jenkinsSyncHistoryRepository,
//        IJenkinsViewRepository jenkinsViewRepository,
//        IJenkinsJobRepository jenkinsJobRepository,
//        IJenkinsBuildRepository jenkinsBuildRepository
//    ){
//        super(jenkinsConfigRepository);
//        this.jenkinsConfigRepository = jenkinsConfigRepository;
//        this.jenkinsSyncHistoryRepository = jenkinsSyncHistoryRepository;
//        this.jenkinsViewRepository = jenkinsViewRepository;
//        this.jenkinsJobRepository = jenkinsJobRepository;
//        this.jenkinsBuildRepository = jenkinsBuildRepository;
//    }
//
//    private RestTemplate createRestTemplate() {
//        return new RestTemplateBuilder()
//            .setConnectTimeout(Duration.ofSeconds(30))
//            .setReadTimeout(Duration.ofSeconds(30))
//            .build();
//    }
//
//    private HttpEntity<String> createHttpEntity(String username, String password) {
//        HttpHeaders headers = new HttpHeaders();
//        String auth = username + ":" + password;
//        byte[] encodedAuth = Base64.getEncoder().encode(auth.getBytes());
//        headers.set("Authorization", "Basic " + new String(encodedAuth));
//        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
//        return new HttpEntity<>(headers);
//    }
//
//    @Transactional
//    public JenkinsConfig save(JenkinsConfig config) {
//        if (jenkinsConfigRepository.existsByNameAndDeletedFalse(config.getName())) {
//            throw new RuntimeException("Jenkins名称已存在");
//        }
//        return jenkinsConfigRepository.save(config);
//    }
//
//    @Transactional
//    public JenkinsConfig update(Long id, JenkinsConfig config) {
//        JenkinsConfig existing = jenkinsConfigRepository.findById(id)
//            .orElseThrow(() -> new RuntimeException("Jenkins配置不存在"));
//
//        if (!existing.getName().equals(config.getName())
//            && jenkinsConfigRepository.existsByNameAndDeletedFalse(config.getName())) {
//            throw new RuntimeException("Jenkins名称已存在");
//        }
//
//        config.setId(id);
//        config.setVersion(existing.getVersion());
//        config.setDeleted(existing.getDeleted());
//        return jenkinsConfigRepository.save(config);
//    }
//
//    @Override
//    public boolean testConnection(JenkinsTestConnectionDTO dto) {
//        try {
//            String url = String.format("%s/api/json", dto.getUrl().trim());
//            ResponseEntity<Map> response = createRestTemplate().exchange(
//                url,
//                HttpMethod.GET,
//                createHttpEntity(dto.getUsername(), dto.getPassword()),
//                Map.class
//            );
//
//            if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
//                log.info("Jenkins连接测试成功");
//                return true;
//            }
//
//            log.error("Jenkins连接测试失败: 响应状态码 {}", response.getStatusCode());
//            return false;
//        } catch (Exception e) {
//            log.error("Jenkins连接测试失败: {}", e.getMessage());
//            return false;
//        }
//    }
//
//    @Override
//    public Long asyncSyncAll(Long jenkinsId) {
//        // 检查是否已有同步任务在运行
//        if (RUNNING_TASKS.containsKey(jenkinsId)) {
//            log.warn("Jenkins已有同步任务正在运行中, jenkinsId: {}", jenkinsId);
//            throw new ApiException("该Jenkins已有同步任务正在运行中");
//        }
//
//        log.info("开始同步Jenkins数据, jenkinsId: {}", jenkinsId);
//
//        JenkinsConfig config = jenkinsConfigRepository.findById(jenkinsId)
//            .orElseThrow(() -> new ApiException("Jenkins配置不存在"));
//
//        // 创建全量同步历史记录
//        JenkinsSyncHistory allHistory = createSyncHistory(jenkinsId, JenkinsSyncHistory.SyncType.ALL);
//
//        // 标记任务开始运行
//        RUNNING_TASKS.put(jenkinsId, true);
//
//        try {
//            // 1. 同步视图
//            JenkinsSyncHistory viewHistory = createSyncHistory(jenkinsId, JenkinsSyncHistory.SyncType.VIEW);
//            try {
//                syncViews(config, viewHistory);
//            } catch (Exception e) {
//                log.error("视图同步失败", e);
//                updateSyncHistory(viewHistory, JenkinsSyncHistory.SyncStatus.FAILED, e.getMessage());
//                throw e;
//            }
//
//            // 2. 同步作业
//            JenkinsSyncHistory jobHistory = createSyncHistory(jenkinsId, JenkinsSyncHistory.SyncType.JOB);
//            try {
//                syncJobs(config, jobHistory);
//            } catch (Exception e) {
//                log.error("作业同步失败", e);
//                updateSyncHistory(jobHistory, JenkinsSyncHistory.SyncStatus.FAILED, e.getMessage());
//                throw e;
//            }
//
//            // 3. 同步构建
//            JenkinsSyncHistory buildHistory = createSyncHistory(jenkinsId, JenkinsSyncHistory.SyncType.BUILD);
//            try {
//                syncBuilds(config, buildHistory);
//            } catch (Exception e) {
//                log.error("构建同步失败", e);
//                updateSyncHistory(buildHistory, JenkinsSyncHistory.SyncStatus.FAILED, e.getMessage());
//                throw e;
//            }
//
//            // 更新全量同步状态
//            updateSyncHistory(allHistory, JenkinsSyncHistory.SyncStatus.SUCCESS, null);
//            config.setLastAllSyncTime(LocalDateTime.now());
//            jenkinsConfigRepository.save(config);
//            log.info("Jenkins数据同步完成, jenkinsId: {}", jenkinsId);
//
//        } catch (Exception e) {
//            log.error("Jenkins数据同步失败", e);
//            updateSyncHistory(allHistory, JenkinsSyncHistory.SyncStatus.FAILED, e.getMessage());
//        } finally {
//            RUNNING_TASKS.remove(jenkinsId);
//        }
//
//        return allHistory.getId();
//    }
//
//    /**
//     * 同步Jenkins视图
//     * @param config Jenkins配置
//     * @param history 同步历史记录
//     */
//    private void syncViews(JenkinsConfig config, JenkinsSyncHistory history) {
//        String url = String.format("%s/api/json?tree=views[name,url,description]", config.getUrl().trim());
//        ResponseEntity<Map<String, Object>> response = createRestTemplate().exchange(
//            url,
//            HttpMethod.GET,
//            createHttpEntity(config.getUsername(), config.getPassword()),
//            new ParameterizedTypeReference<>() {}
//        );
//
//        if (response.getBody() != null) {
//            List<Map<String, Object>> views = (List<Map<String, Object>>) response.getBody().get("views");
//            List<JenkinsView> viewsToSave = new ArrayList<>();
//            Map<String, JenkinsView> existingViews = jenkinsViewRepository
//                .findByJenkinsIdAndDeletedFalse(config.getId())
//                .stream()
//                .collect(Collectors.toMap(JenkinsView::getViewName, v -> v));
//
//            for (Map<String, Object> view : views) {
//                String viewName = (String) view.get("name");
//                // 跳过 "All" 视图
//                if ("All".equalsIgnoreCase(viewName)) {
//                    log.debug("跳过All视图同步 - 仓库: {}", config.getName());
//                    continue;
//                }
//
//                JenkinsView jenkinsView = existingViews.getOrDefault(viewName, new JenkinsView());
//                jenkinsView.setJenkinsId(config.getId());
//                jenkinsView.setViewName(viewName);
//                jenkinsView.setViewUrl((String) view.get("url"));
//                jenkinsView.setDescription((String) view.get("description"));
//                viewsToSave.add(jenkinsView);
//            }
//
//            if (!viewsToSave.isEmpty()) {
//                jenkinsViewRepository.saveAll(viewsToSave);
//                log.info("同步Jenkins视图完成, 总数: {}, 实际同步: {}", views.size(), viewsToSave.size());
//
//                // 更新配置的同步时间
//                config.setLastViewSyncTime(LocalDateTime.now());
//                jenkinsConfigRepository.save(config);
//            }
//        }
//
//        updateSyncHistory(history, JenkinsSyncHistory.SyncStatus.SUCCESS, null);
//    }
//
//    @Transactional
//    public void updateSyncHistory(JenkinsSyncHistory history,
//                                 JenkinsSyncHistory.SyncStatus status,
//                                 String errorMessage) {
//        // 重新获取最新的历史记录
//        JenkinsSyncHistory latestHistory = jenkinsSyncHistoryRepository.findById(history.getId())
//            .orElseThrow(() -> new ApiException("同步历史记录不存在"));
//
//        latestHistory.setStatus(status);
//        latestHistory.setEndTime(LocalDateTime.now());
//        latestHistory.setErrorMessage(errorMessage);
//        jenkinsSyncHistoryRepository.save(latestHistory);
//    }
//
//    @Transactional
//    public JenkinsSyncHistory createSyncHistory(Long jenkinsId, JenkinsSyncHistory.SyncType syncType) {
//        JenkinsSyncHistory history = new JenkinsSyncHistory();
//        history.setJenkinsId(jenkinsId);
//        history.setSyncType(syncType);
//        history.setStartTime(LocalDateTime.now());
//        history.setStatus(JenkinsSyncHistory.SyncStatus.RUNNING);
//        return jenkinsSyncHistoryRepository.save(history);
//    }
//
//    /**
//     * 同步Jenkins作业
//     * @param config Jenkins配置
//     * @param history 同步历记录
//     */
//    private void syncJobs(JenkinsConfig config, JenkinsSyncHistory history) {
//        String url = String.format("%s/api/json?tree=jobs[name,url,description,buildable,lastBuild[number,timestamp,result]]",
//            config.getUrl().trim());
//        ResponseEntity<Map<String, Object>> response = createRestTemplate().exchange(
//            url,
//            HttpMethod.GET,
//            createHttpEntity(config.getUsername(), config.getPassword()),
//            new ParameterizedTypeReference<>() {}
//        );
//
//        if (response.getBody() != null) {
//            List<Map<String, Object>> jobs = (List<Map<String, Object>>) response.getBody().get("jobs");
//            List<JenkinsJob> jobsToSave = new ArrayList<>();
//            Map<String, JenkinsJob> existingJobs = jenkinsJobRepository
//                .findByJenkinsIdAndDeletedFalse(config.getId())
//                .stream()
//                .collect(Collectors.toMap(JenkinsJob::getJobName, j -> j));
//
//            for (Map<String, Object> job : jobs) {
//                String jobName = (String) job.get("name");
//                JenkinsJob jenkinsJob = existingJobs.getOrDefault(jobName, new JenkinsJob());
//                jenkinsJob.setJenkinsId(config.getId());
//                jenkinsJob.setJobName(jobName);
//                jenkinsJob.setJobUrl((String) job.get("url"));
//                jenkinsJob.setDescription((String) job.get("description"));
//                jenkinsJob.setBuildable((Boolean) job.get("buildable"));
//
//                Map<String, Object> lastBuild = (Map<String, Object>) job.get("lastBuild");
//                if (lastBuild != null) {
//                    jenkinsJob.setLastBuildNumber(((Number) lastBuild.get("number")).intValue());
//                    long timestamp = ((Number) lastBuild.get("timestamp")).longValue();
//                    jenkinsJob.setLastBuildTime(LocalDateTime.ofInstant(
//                        Instant.ofEpochMilli(timestamp),
//                        ZoneId.systemDefault()
//                    ));
//                    jenkinsJob.setLastBuildStatus((String) lastBuild.get("result"));
//                }
//                jobsToSave.add(jenkinsJob);
//            }
//
//            if (!jobsToSave.isEmpty()) {
//                jenkinsJobRepository.saveAll(jobsToSave);
//                log.info("同步Jenkins作业完成, 总数: {}, 实际同步: {}", jobs.size(), jobsToSave.size());
//
//                // 更新配置的同步时间
//                config.setLastJobSyncTime(LocalDateTime.now());
//                jenkinsConfigRepository.save(config);
//            }
//        }
//
//        updateSyncHistory(history, JenkinsSyncHistory.SyncStatus.SUCCESS, null);
//    }
//
//    /**
//     * 同步Jenkins构建
//     * @param config Jenkins配置
//     * @param history 同步历史记录
//     */
//    private void syncBuilds(JenkinsConfig config, JenkinsSyncHistory history) {
//        List<JenkinsJob> jobs = jenkinsJobRepository.findByJenkinsIdAndDeletedFalse(config.getId());
//        List<JenkinsBuild> allBuildsToSave = new ArrayList<>();
//
//        for (JenkinsJob job : jobs) {
//            String url = String.format("%s/api/json?tree=builds[number,url,timestamp,result,duration,actions[causes[*]]]",
//                job.getJobUrl().trim());
//            ResponseEntity<Map<String, Object>> response = createRestTemplate().exchange(
//                url,
//                HttpMethod.GET,
//                createHttpEntity(config.getUsername(), config.getPassword()),
//                new ParameterizedTypeReference<>() {}
//            );
//
//            if (response.getBody() != null) {
//                List<Map<String, Object>> builds = (List<Map<String, Object>>) response.getBody().get("builds");
//                Map<Integer, JenkinsBuild> existingBuilds = jenkinsBuildRepository
//                    .findByJobIdAndDeletedFalse(job.getId())
//                    .stream()
//                    .collect(Collectors.toMap(JenkinsBuild::getBuildNumber, b -> b));
//
//                for (Map<String, Object> build : builds) {
//                    Integer buildNumber = ((Number) build.get("number")).intValue();
//                    JenkinsBuild jenkinsBuild = existingBuilds.getOrDefault(buildNumber, new JenkinsBuild());
//                    jenkinsBuild.setJenkinsId(config.getId());
//                    jenkinsBuild.setJobId(job.getId());
//                    jenkinsBuild.setBuildNumber(buildNumber);
//                    jenkinsBuild.setBuildUrl((String) build.get("url"));
//                    jenkinsBuild.setBuildStatus((String) build.get("result"));
//
//                    long timestamp = ((Number) build.get("timestamp")).longValue();
//                    jenkinsBuild.setStartTime(LocalDateTime.ofInstant(
//                        Instant.ofEpochMilli(timestamp),
//                        ZoneId.systemDefault()
//                    ));
//
//                    jenkinsBuild.setDuration(((Number) build.get("duration")).longValue());
//
//                    // 处理触发原因
//                    List<Map<String, Object>> actions = (List<Map<String, Object>>) build.get("actions");
//                    if (actions != null) {
//                        for (Map<String, Object> action : actions) {
//                            if (action != null && action.containsKey("causes")) {
//                                List<Map<String, Object>> causes = (List<Map<String, Object>>) action.get("causes");
//                                if (causes != null && !causes.isEmpty()) {
//                                    jenkinsBuild.setTriggerCause((String) causes.get(0).get("shortDescription"));
//                                    break;
//                                }
//                            }
//                        }
//                    }
//                    allBuildsToSave.add(jenkinsBuild);
//                }
//                log.info("处理Jenkins构建历史, 作业: {}, 构建数量: {}", job.getJobName(), builds.size());
//            }
//        }
//
//        if (!allBuildsToSave.isEmpty()) {
//            jenkinsBuildRepository.saveAll(allBuildsToSave);
//            log.info("同步Jenkins构建完成, 总数: {}", allBuildsToSave.size());
//
//            // 更新配置的同步时间
//            config.setLastBuildSyncTime(LocalDateTime.now());
//            jenkinsConfigRepository.save(config);
//        }
//
//        updateSyncHistory(history, JenkinsSyncHistory.SyncStatus.SUCCESS, null);
//    }
//
//    @Override
//    public List<JenkinsSyncHistoryDTO> getSyncHistories() {
//        List<JenkinsSyncHistory> histories = jenkinsSyncHistoryRepository.findTop50ByOrderByStartTimeDesc();
//
//        return histories.stream()
//            .map(history -> {
//                JenkinsConfig config = jenkinsConfigRepository.findById(history.getJenkinsId())
//                    .orElse(null);
//
//                return JenkinsSyncHistoryDTO.builder()
//                    .id(history.getId())
//                    .jenkinsId(history.getJenkinsId())
//                    .jenkinsName(config != null ? config.getName() : "未知Jenkins")
//                    .syncType(history.getSyncType())
//                    .status(history.getStatus())
//                    .startTime(history.getStartTime())
//                    .endTime(history.getEndTime())
//                    .errorMessage(history.getErrorMessage())
//                    .build();
//            })
//            .collect(Collectors.toList());
//    }
//
//    @Transactional
//    public void updateLastSyncTime(Long jenkinsId, String timeField) {
//        // 使用 JPQL 更新指定字段
//        String jpql = String.format("UPDATE JenkinsConfig j SET j.%s = :now WHERE j.id = :id", timeField);
//        entityManager.createQuery(jpql)
//            .setParameter("now", LocalDateTime.now())
//            .setParameter("id", jenkinsId)
//            .executeUpdate();
//    }
//
//    @Override
//    public Long asyncSyncView(Long jenkinsId) {
//        // 检查是否已有同步任务在运行
//        if (RUNNING_TASKS.containsKey(jenkinsId)) {
//            log.warn("Jenkins已有同步任务正在运行中, jenkinsId: {}", jenkinsId);
//            throw new ApiException("该Jenkins已有同步任务正在运行中");
//        }
//
//        log.info("开始同步Jenkins视图, jenkinsId: {}", jenkinsId);
//
//        JenkinsConfig config = jenkinsConfigRepository.findById(jenkinsId)
//            .orElseThrow(() -> new ApiException("Jenkins配置不存在"));
//
//        // 创建同步历史记录
//        JenkinsSyncHistory history = createSyncHistory(jenkinsId, JenkinsSyncHistory.SyncType.VIEW);
//
//        // 标记任务开始运行
//        RUNNING_TASKS.put(jenkinsId, true);
//
//        CompletableFuture.runAsync(() -> {
//            try {
//                syncViews(config, history);
//            } catch (Exception e) {
//                log.error("视图同步失败", e);
//                updateSyncHistory(history, JenkinsSyncHistory.SyncStatus.FAILED, e.getMessage());
//            } finally {
//                RUNNING_TASKS.remove(jenkinsId);
//            }
//        });
//
//        return history.getId();
//    }
//
//    @Override
//    public Long asyncSyncJob(Long jenkinsId) {
//        // 检查是否已有同步任务在运行
//        if (RUNNING_TASKS.containsKey(jenkinsId)) {
//            log.warn("Jenkins已有同步任务正在运行中, jenkinsId: {}", jenkinsId);
//            throw new ApiException("该Jenkins已有同步任务正在运行中");
//        }
//
//        log.info("开始同步Jenkins作业, jenkinsId: {}", jenkinsId);
//
//        JenkinsConfig config = jenkinsConfigRepository.findById(jenkinsId)
//            .orElseThrow(() -> new ApiException("Jenkins配置不存在"));
//
//        // 创建同步历史记录
//        JenkinsSyncHistory history = createSyncHistory(jenkinsId, JenkinsSyncHistory.SyncType.JOB);
//
//        // 标记任务开始运行
//        RUNNING_TASKS.put(jenkinsId, true);
//
//        CompletableFuture.runAsync(() -> {
//            try {
//                syncJobs(config, history);
//            } catch (Exception e) {
//                log.error("作业同步失败", e);
//                updateSyncHistory(history, JenkinsSyncHistory.SyncStatus.FAILED, e.getMessage());
//            } finally {
//                RUNNING_TASKS.remove(jenkinsId);
//            }
//        });
//
//        return history.getId();
//    }
//
//    @Override
//    public Long asyncSyncBuild(Long jenkinsId) {
//        // 检查是否已有同步任务在运行
//        if (RUNNING_TASKS.containsKey(jenkinsId)) {
//            log.warn("Jenkins已有同步任务正在运行中, jenkinsId: {}", jenkinsId);
//            throw new ApiException("该Jenkins已有同步任务正在运行中");
//        }
//
//        log.info("开始同步Jenkins构建, jenkinsId: {}", jenkinsId);
//
//        JenkinsConfig config = jenkinsConfigRepository.findById(jenkinsId)
//            .orElseThrow(() -> new ApiException("Jenkins配置不存在"));
//
//        // 创建同步历史记录
//        JenkinsSyncHistory history = createSyncHistory(jenkinsId, JenkinsSyncHistory.SyncType.BUILD);
//
//        // 标记任务开始运行
//        RUNNING_TASKS.put(jenkinsId, true);
//
//        CompletableFuture.runAsync(() -> {
//            try {
//                syncBuilds(config, history);
//            } catch (Exception e) {
//                log.error("构建同步失败", e);
//                updateSyncHistory(history, JenkinsSyncHistory.SyncStatus.FAILED, e.getMessage());
//            } finally {
//                RUNNING_TASKS.remove(jenkinsId);
//            }
//        });
//
//        return history.getId();
//    }
//
//    @Override
//    public List<ViewResponse> getViews(Long jenkinsId) {
//        List<JenkinsView> views = jenkinsViewRepository.findByJenkinsIdAndDeletedFalse(jenkinsId);
//        return views.stream()
//            .map(view -> ViewResponse.builder()
//                .id(view.getId())
//                .jenkinsId(view.getJenkinsId())
//                .viewName(view.getViewName())
//                .viewUrl(view.getViewUrl())
//                .description(view.getDescription())
//                .build())
//            .collect(Collectors.toList());
//    }
//
//    @Override
//    public List<JobResponse> getJobs(Long jenkinsId) {
//        List<JenkinsJob> jobs = jenkinsJobRepository.findByJenkinsIdAndDeletedFalse(jenkinsId);
//        return jobs.stream()
//            .map(job -> JobResponse.builder()
//                .id(job.getId())
//                .jenkinsId(job.getJenkinsId())
//                .viewId(job.getView() != null ? job.getView().getId() : null)
//                .viewName(job.getView() != null ? job.getView().getViewName() : null)
//                .jobName(job.getJobName())
//                .jobUrl(job.getJobUrl())
//                .description(job.getDescription())
//                .buildable(job.getBuildable())
//                .lastBuildNumber(job.getLastBuildNumber())
//                .lastBuildTime(job.getLastBuildTime())
//                .lastBuildStatus(job.getLastBuildStatus())
//                .build())
//            .collect(Collectors.toList());
//    }
//
//    @Override
//    public List<BuildResponse> getBuilds(Long jenkinsId, Long jobId) {
//        List<JenkinsBuild> builds = jenkinsBuildRepository.findByJobIdAndDeletedFalseOrderByBuildNumberDesc(jobId);
//        return builds.stream()
//            .map(build -> BuildResponse.builder()
//                .id(build.getId())
//                .jenkinsId(build.getJenkinsId())
//                .jobId(build.getJobId())
//                .buildNumber(build.getBuildNumber())
//                .buildUrl(build.getBuildUrl())
//                .buildStatus(build.getBuildStatus())
//                .startTime(build.getStartTime())
//                .duration(build.getDuration())
//                .triggerCause(build.getTriggerCause())
//                .build())
//            .collect(Collectors.toList());
//    }
//
//    @Override
//    public List<JobResponse> getJobsByView(Long jenkinsId, String viewName) {
//        List<JenkinsJob> jobs = jenkinsJobRepository.findJobsByJenkinsIdAndViewName(jenkinsId, viewName);
//        return jobs.stream()
//            .map(job -> JobResponse.builder()
//                .id(job.getId())
//                .jenkinsId(job.getJenkinsId())
//                .viewId(job.getView().getId())
//                .viewName(job.getView().getViewName())
//                .jobName(job.getJobName())
//                .jobUrl(job.getJobUrl())
//                .description(job.getDescription())
//                .buildable(job.getBuildable())
//                .lastBuildNumber(job.getLastBuildNumber())
//                .lastBuildTime(job.getLastBuildTime())
//                .lastBuildStatus(job.getLastBuildStatus())
//                .build())
//            .collect(Collectors.toList());
//    }
//}