SEEC-DataAnalysis2.0/src/main/java/com/seecoder/dataanalysis/analysis/impl/DevcloudDataAnalysisServiceImpl.java

package com.seecoder.dataanalysis.analysis.impl;

import com.seecoder.dataanalysis.analysis.DevcloudDataAnalysisService;
import com.seecoder.dataanalysis.data.dao.devcloud.*;
import com.seecoder.dataanalysis.data.dao.eval.UserDao;
import com.seecoder.dataanalysis.data.entity.devcloud.*;
import com.seecoder.dataanalysis.data.entity.devcloud.display.*;
import com.seecoder.dataanalysis.data.entity.eval.User;
import com.seecoder.dataanalysis.vo.devcloud.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * @author Peng Yiyan
 * @since 2022/03/12
 */
@Service
public class DevcloudDataAnalysisServiceImpl implements DevcloudDataAnalysisService {

    @Autowired
    private DevcloudInfoDao devcloudInfoDao;
    @Autowired
    private DevcloudProjectDao devcloudProjectDao;
    @Autowired
    private DevcloudUserDao devcloudUserDao;
    @Autowired
    private ProjectRelateDao projectRelateDao;
    @Autowired
    private UserDao userDao;
    @Autowired
    private ProjectDao projectDao;


    @Override
    public DevcloudInfo updateDevInfoType100(BugInfoDTO bugInfoDTO){
        Integer projectId = bugInfoDTO.getProjectId();
        DevcloudInfo devcloudInfo;
        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }
        List<BugInfo> bugInfoList = devcloudInfo.getBugList();
        boolean exist = false;
        for(int i=0;i<bugInfoList.size();i++){
            //如果已经存在bug_id，则视为对bugInfo的修改
//            System.out.println("--------"+bugInfoList.get(i).getBugId());
            if(bugInfoList.get(i).getBugId().equals(bugInfoDTO.getBugId())){
                exist = true;
                bugInfoList.get(i).setBugId(bugInfoDTO.getBugId());
                bugInfoList.get(i).setUserId(bugInfoDTO.getUserId());
                bugInfoList.get(i).setPriority(bugInfoDTO.getPriority());
                bugInfoList.get(i).setTitle(bugInfoDTO.getTitle());
                bugInfoList.get(i).setDescription(bugInfoDTO.getDescription());
                bugInfoList.get(i).setTimeToTake(bugInfoDTO.getTimeToTake());
                bugInfoList.get(i).setBugState(bugInfoDTO.getBugState());
                break;
            }
        }
        //如果不存在bug_id，将bugInfo加入List
        if(!exist){
            BugInfo bugInfoNew = new BugInfo();
            bugInfoNew.setBugId(bugInfoDTO.getBugId());
            bugInfoNew.setUserId(bugInfoDTO.getUserId());
            bugInfoNew.setPriority(bugInfoDTO.getPriority());
            bugInfoNew.setTitle(bugInfoDTO.getTitle());
            bugInfoNew.setDescription(bugInfoDTO.getDescription());
            bugInfoNew.setTimeToTake(bugInfoDTO.getTimeToTake());
            bugInfoNew.setBugState(bugInfoDTO.getBugState());

            bugInfoList.add(bugInfoNew);
        }

        devcloudInfo.setBugList(bugInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudInfo updateDevInfoType101(CommitInfoDTO commitInfoDTO){
        Integer projectId = commitInfoDTO.getProjectId();
        DevcloudInfo devcloudInfo;

        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }

        List<CommitInfo> commitInfoList = devcloudInfo.getCommitList();

        boolean exist = false;
        for(int i=0;i<commitInfoList.size();i++){
            if(commitInfoList.get(i).getCommitId().equals(commitInfoDTO.getCommitId())){
                exist = true;
                break;
            }
        }

        if(!exist){
            //新建commit信息
            CommitInfo commitInfo = new CommitInfo();
            commitInfo.setCommitId(commitInfoDTO.getCommitId());
            commitInfo.setUserId(commitInfoDTO.getUserId());
            commitInfo.setCommitName(commitInfoDTO.getCommitName());
            commitInfo.setCommitTime(commitInfoDTO.getCommitTime());
            commitInfo.setMessage(commitInfoDTO.getMessage());
            commitInfo.setType(commitInfoDTO.getType());

            commitInfoList.add(commitInfo);
        }else {
            System.out.println("请勿重复插入");
        }

        devcloudInfo.setCommitList(commitInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudInfo updateDevInfoType102(TestInfoDTO testInfoDTO){
        Integer projectId = testInfoDTO.getProjectId();
        DevcloudInfo devcloudInfo;

        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }

        List<TestInfo> testInfoList = devcloudInfo.getTestList();

        boolean exist = false;
        for(int i=0;i<testInfoList.size();i++){
            if(testInfoList.get(i).getApiTestId().equals(testInfoDTO.getApiTestId())){
                exist = true;
                break;
            }
        }

        //新建测试信息
        if(!exist){
            TestInfo testInfo = new TestInfo();
            testInfo.setApiTestId(testInfoDTO.getApiTestId());
            testInfo.setUserId(testInfoDTO.getUserId());
            testInfo.setSuccess(testInfoDTO.getSuccess());
            testInfo.setFailure(testInfoDTO.getFailure());

            testInfoList.add(testInfo);
        }else {
            System.out.println("请勿重复插入");
        }

        devcloudInfo.setTestList(testInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudInfo updateDevInfoType103(PipelineCreationDTO pipelineCreationDTO){
        Integer projectId = pipelineCreationDTO.getProjectId();
        DevcloudInfo devcloudInfo;

        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }

        List<PipelineInfo> pipelineInfoList = devcloudInfo.getPipelineList();

        boolean exist = false;
        for(int i=0;i<pipelineInfoList.size();i++){
            if(pipelineInfoList.get(i).getPipelineId().equals(pipelineCreationDTO.getPipelineId())){
                exist = true;
                break;
            }
        }

        //新建流水线信息
        if(!exist){
//            System.out.println(pipelineInfoList.size());
//            System.out.println(pipelineCreationDTO.getPipelineId());
            PipelineInfo pipelineInfo = new PipelineInfo();
            pipelineInfo.setPipelineId(pipelineCreationDTO.getPipelineId());

            pipelineInfoList.add(pipelineInfo);
        }else {
            System.out.println("请勿重复插入");
        }

        devcloudInfo.setPipelineList(pipelineInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudInfo updateDevInfoType104(PipelineDeletionDTO pipelineDeletionDTO){
        Integer projectId = pipelineDeletionDTO.getProjectId();
        Integer pipelineId = pipelineDeletionDTO.getPipelineId();
        DevcloudInfo devcloudInfo;

        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }

        List<PipelineInfo> pipelineInfoList = devcloudInfo.getPipelineList();

        //找到对应的id，删除
        for(int i=0;i<pipelineInfoList.size();i++){
            if(pipelineInfoList.get(i).getPipelineId().equals(pipelineId)){
//                System.out.println("will remove");
                pipelineInfoList.remove(i);
                break;
            }
        }

        devcloudInfo.setPipelineList(pipelineInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudInfo updateDevInfoType105(PipelineDeployDTO pipelineDeployDTO){
        Integer projectId = pipelineDeployDTO.getProjectId();
        Integer pipelineId = pipelineDeployDTO.getPipelineId();
//        DevcloudInfo devcloudInfo = devcloudInfoDao.findById(projectId).get();

        DevcloudInfo devcloudInfo;

        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }

        List<PipelineInfo> pipelineInfoList = devcloudInfo.getPipelineList();


        //找到对应的id，存入部署信息
        for(int i=0;i<pipelineInfoList.size();i++){
            if(pipelineInfoList.get(i).getPipelineId().equals(pipelineId)){
                List<RecordInfo> recordInfoList = pipelineInfoList.get(i).getRecordList();
                RecordInfo recordInfo = new RecordInfo();
                recordInfo.setRecordId(pipelineDeployDTO.getRecordId());
                recordInfo.setUserId(pipelineDeployDTO.getUserId());
                recordInfo.setResult(pipelineDeployDTO.getResult());
                recordInfoList.add(recordInfo);
                break;
            }
        }

        devcloudInfo.setPipelineList(pipelineInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudInfo updateDevInfoType106(TreeNodeInfoDTO treeNodeInfoDTO){
        Integer projectId = treeNodeInfoDTO.getProjectId();
        DevcloudInfo devcloudInfo;
        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }
        List<TreeNodeInfo> treeNodeInfoList = devcloudInfo.getTreeNodeList();
        boolean exist = false;
        for(int i=0;i<treeNodeInfoList.size();i++){
            //如果已经存在node_id，则视为对节点信息的修改
            if(treeNodeInfoList.get(i).getNodeId().equals(treeNodeInfoDTO.getNodeId())){
                exist = true;
                treeNodeInfoList.get(i).setTitle(treeNodeInfoDTO.getTitle());
                treeNodeInfoList.get(i).setUserId(treeNodeInfoDTO.getUserId());
                treeNodeInfoList.get(i).setType(treeNodeInfoDTO.getType());
                treeNodeInfoList.get(i).setPriority(treeNodeInfoDTO.getPriority());
                treeNodeInfoList.get(i).setState(treeNodeInfoDTO.getState());
                treeNodeInfoList.get(i).setTimeToTake(treeNodeInfoDTO.getTimeToTake());
                treeNodeInfoList.get(i).setParentId(treeNodeInfoDTO.getParentId());
                treeNodeInfoList.get(i).setDeep(treeNodeInfoDTO.getDeep());
                break;
            }
        }
        //如果不存在node_id，则视为添加节点
        if(!exist){
            TreeNodeInfo treeNodeInfoNew = new TreeNodeInfo();
            treeNodeInfoNew.setNodeId(treeNodeInfoDTO.getNodeId());
            treeNodeInfoNew.setTitle(treeNodeInfoDTO.getTitle());
            treeNodeInfoNew.setUserId(treeNodeInfoDTO.getUserId());
            treeNodeInfoNew.setType(treeNodeInfoDTO.getType());
            treeNodeInfoNew.setPriority(treeNodeInfoDTO.getPriority());
            treeNodeInfoNew.setState(treeNodeInfoDTO.getState());
            treeNodeInfoNew.setTimeToTake(treeNodeInfoDTO.getTimeToTake());
            treeNodeInfoNew.setParentId(treeNodeInfoDTO.getParentId());
            treeNodeInfoNew.setDeep(treeNodeInfoDTO.getDeep());

            treeNodeInfoList.add(treeNodeInfoNew);
        }

        devcloudInfo.setTreeNodeList(treeNodeInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudInfo updateDevInfoType107(TreeNodeDeletionDTO treeNodeDeletionDTO){
        Integer projectId = treeNodeDeletionDTO.getProjectId();
        DevcloudInfo devcloudInfo;

        Optional<DevcloudInfo> result = devcloudInfoDao.findById(projectId);
        if(!result.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
        }else {
            devcloudInfo = devcloudInfoDao.findById(projectId).get();
        }

        List<TreeNodeInfo> treeNodeInfoList = devcloudInfo.getTreeNodeList();
        List<Integer> nodeIds = treeNodeDeletionDTO.getNodeIds();
        for(int i=0;i<nodeIds.size();i++){
            Integer nodeId = nodeIds.get(i);
            for(int j=0;j<treeNodeInfoList.size();j++){
                if(treeNodeInfoList.get(j).getNodeId().equals(nodeId)){
                    treeNodeInfoList.remove(j);
                    break;
                }
            }
        }

        devcloudInfo.setTreeNodeList(treeNodeInfoList);
        devcloudInfoDao.save(devcloudInfo);
        return devcloudInfo;
    }

    @Override
    public DevcloudProject updateDevInfoType108(AddProjectDTO addProjectDTO){
        Integer projectId = addProjectDTO.getProjectId();
        DevcloudProject devcloudProject;

        Optional<DevcloudProject> result = devcloudProjectDao.findById(projectId);

        //如果项目-用户信息不存在，则新建项目-用户信息，否则直接查询
        if(!result.isPresent()){
            devcloudProject = new DevcloudProject();
            devcloudProject.setProjectId(projectId);
//            devcloudProjectDao.save(devcloudProject);
        }else {
            devcloudProject = devcloudProjectDao.findById(projectId).get();
        }

        List<Integer> memberIds = devcloudProject.getUserIds();
        //如果该添加日志中的成员id还不在项目中，则加入
        if(!memberIds.contains(addProjectDTO.getUserId())){
            memberIds.add(addProjectDTO.getUserId());
        }

        devcloudProject.setUserIds(memberIds);
        devcloudProjectDao.save(devcloudProject);

        Integer userId = addProjectDTO.getUserId();

        //查询该项目是否有关联项目，如果有关联项目，需要把该成员也加入关联项目中
        Optional<ProjectRelate> result2 = projectRelateDao.findById(projectId);
        Integer relateId = -1;
        //如果存在关联项目
        if(result2.isPresent()){
            relateId = projectRelateDao.findById(projectId).get().getRelateId();
        }

        DevcloudProject relateProject;
        if(relateId != -1){
            Optional<DevcloudProject> result3 = devcloudProjectDao.findById(relateId);
            if(!result3.isPresent()){
                relateProject = new DevcloudProject();
                relateProject.setProjectId(relateId);
            }else {
                relateProject = devcloudProjectDao.findById(relateId).get();
            }

            List<Integer> relateMembers = relateProject.getUserIds();
            if(!relateMembers.contains(userId)){
                relateMembers.add(userId);
                relateProject.setUserIds(relateMembers);
            }

            devcloudProjectDao.save(relateProject);
        }

        //处理完项目-用户关系，现在处理用户-项目关系
        //所有的devcloudUser都在此处创建
        DevcloudUser devcloudUser;

        Optional<DevcloudUser> result1 = devcloudUserDao.findById(userId);

        if(!result1.isPresent()){
            devcloudUser = new DevcloudUser();
            devcloudUser.setUserId(userId);
        }else {
            devcloudUser = devcloudUserDao.findById(userId).get();
        }

        List<Integer> projectIds = devcloudUser.getProjectIds();
        if(!projectIds.contains(addProjectDTO.getProjectId())){
            projectIds.add(addProjectDTO.getProjectId());
        }
        if(relateId!=-1){
            if(!projectIds.contains(relateId)){
                projectIds.add(relateId);
            }
        }

        devcloudUser.setProjectIds(projectIds);
        devcloudUserDao.save(devcloudUser);

        return devcloudProject;
    }

    @Override
    public ProjectRelate updateDevInfoType109(RelateProjectDTO relateProjectDTO){
        Integer projectAId = relateProjectDTO.getProjectAId();
        Integer projectBId = relateProjectDTO.getProjectBId();
        ProjectRelate projectRelate;

        Optional<ProjectRelate> result = projectRelateDao.findById(projectAId);
        if(!result.isPresent()){
            projectRelate = new ProjectRelate();
            projectRelate.setProjectId(projectAId);
            projectRelate.setRelateId(relateProjectDTO.getProjectBId());
            projectRelateDao.save(projectRelate);
        }else {
            //项目的关联项目只能有一个
            projectRelate = projectRelateDao.findById(projectAId).get();
            projectRelate.setRelateId(relateProjectDTO.getProjectBId());
            projectRelateDao.save(projectRelate);
        }

        //增加关联后，A和B中的成员应该相同，每个成员也应该加入
        //先将A、B项目中的成员同步
        DevcloudProject projectA, projectB;
        Optional<DevcloudProject> result1 = devcloudProjectDao.findById(projectAId);
        if(!result1.isPresent()){
            projectA = new DevcloudProject();
            projectA.setProjectId(projectAId);
        }else {
            projectA = devcloudProjectDao.findById(projectAId).get();
        }

        Optional<DevcloudProject> result2 = devcloudProjectDao.findById(projectBId);
        if(!result2.isPresent()){
            projectB = new DevcloudProject();
            projectB.setProjectId(projectBId);
        }else {
            projectB = devcloudProjectDao.findById(projectBId).get();
        }

        List<Integer> totalMembers = new ArrayList<>();
        for(Integer id : projectA.getUserIds()){
            if(!totalMembers.contains(id)){
                totalMembers.add(id);
            }
        }
        for(Integer id : projectB.getUserIds()){
            if(!totalMembers.contains(id)){
                totalMembers.add(id);
            }
        }

        projectA.setUserIds(totalMembers);
        projectB.setUserIds(new ArrayList<>(totalMembers));

        devcloudProjectDao.save(projectA);
        devcloudProjectDao.save(projectB);

        //然后将小组成员遍历，将projectA、B都添加
        for(Integer userId : totalMembers){
            DevcloudUser devcloudUser;
            Optional<DevcloudUser> result3 = devcloudUserDao.findById(userId);
            if(!result3.isPresent()){
                devcloudUser = new DevcloudUser();
                devcloudUser.setUserId(userId);
            }else {
                devcloudUser = devcloudUserDao.findById(userId).get();
            }

            List<Integer> projectIds = devcloudUser.getProjectIds();
            if(!projectIds.contains(projectAId)){
                projectIds.add(projectAId);
            }
            if(!projectIds.contains(projectBId)){
                projectIds.add(projectBId);
            }

            devcloudUser.setProjectIds(projectIds);
            devcloudUserDao.save(devcloudUser);
        }


        return projectRelate;
    }

    @Override
    public Project updateDevInfoType110(ProjectDTO projectDTO){
        Integer projectId = projectDTO.getProjectId();
        Project project;

        Optional<Project> result = projectDao.findById(projectId);
        if(!result.isPresent()){
            project = new Project();
        }else {
            System.out.println("请勿重复添加项目");
            return projectDao.findById(projectId).get();
        }

        project.setProjectId(projectId);
        project.setProjectName(projectDTO.getProjectName());
        project.setDescription(projectDTO.getDescription());

        projectDao.save(project);

        //添加项目之后，初始化项目的devInfo
        DevcloudInfo devcloudInfo;
        Optional<DevcloudInfo> result2 = devcloudInfoDao.findById(projectId);
        if(!result2.isPresent()){
            devcloudInfo = new DevcloudInfo(projectId);
            devcloudInfoDao.save(devcloudInfo);
        }

        return project;
    }

    @Override
    public User updateDevInfoType111(UserDTO userDTO){
        Integer userId = userDTO.getUserId();
        User user;

        Optional<User> result = userDao.findById(userId);
        if(!result.isPresent()){
            user = new User();
        }else {
            System.out.println("该用户已存在");
            return userDao.findByUserId(userId);
        }

        user.setUserId(userId);
        user.setName(userDTO.getName());
        user.setRole(userDTO.getRole());
        user.setEmail(userDTO.getEmail());
        user.setPhone(userDTO.getPhone());

        userDao.save(user);
        return user;
    }


    @Override
    public FormatStudent getStudentAnalysis(Integer user_id){
        FormatStudent formatStudent = new FormatStudent();
        User user = userDao.findByUserId(user_id);
        DevcloudUser devcloudUser;

        Optional<DevcloudUser> result = devcloudUserDao.findById(user_id);
        //如果devcloudUser不存在，说明用户还没有加入任何项目
        //但如果存在对应的User信息，则帮用户新建devcloudUser
        if(!result.isPresent()){
//            System.out.println("没有查找到学生id");
        }else {
            devcloudUser = devcloudUserDao.findById(user_id).get();
        }

        //放入展示数据
        formatStudent.setUserId(user_id);
        formatStudent.setName(user.getName());
        formatStudent.setEmail(user.getEmail());

        //根据用户id找到和该用户关联的所有项目id
        List<Integer> projectList = devcloudUserDao.findById(user_id).get().getProjectIds();
        List<Project> projects = new ArrayList<>();
        for(int i=0;i<projectList.size();i++){
            projects.add(projectDao.findById(projectList.get(i)).get());
        }
        //放入个人包含的所有项目信息
        formatStudent.setProjects(projects);

        //放入个人Commit信息，测试信息，流水线信息
        Commit commit = new Commit();
        Test test = new Test();
        Pipeline pipeline = new Pipeline();

        Integer commit_times=0,valid_commit_time=0,buglist_commit=0,feature_commit=0;
        List<String> commit_msg_overview = new ArrayList<>();
        Integer test_success=0,test_failure=0,test_times=0,test_concurrency_count=0;
        Integer pipeline_deploy=0,pipeline_pass=0,pipeline_failure=0;
        //遍历所有相关项目
        for(int i=0;i<projectList.size();i++){
            Integer projectId = projectList.get(i);
            DevcloudInfo devcloudInfo = devcloudInfoDao.findById(projectId).get();
            //遍历devInfo中的commit信息
            List<CommitInfo> commitInfos = devcloudInfo.getCommitList();
            for(CommitInfo commitInfo : commitInfos){
                if(commitInfo.getUserId().equals(user_id)){
                    commit_times++;
                    commit_msg_overview.add(commitInfo.getMessage());
                    //如果是需求的commit
                    if(commitInfo.getType().toLowerCase().equals("tree_id")){
                        feature_commit++;
                    }
                    //如果是bug_list的commit
                    if(commitInfo.getType().toLowerCase().equals("bug_id")){
                        buglist_commit++;
                    }
                    //判断是否是有效的commit
                    if(commitInfo.getMessage().startsWith("feat:")||commitInfo.getMessage().startsWith("fix:")){
                        valid_commit_time++;
                    }
                }
            }
            //遍历devInfo中的test信息
            List<TestInfo> testInfos = devcloudInfo.getTestList();
            for(TestInfo testInfo : testInfos){
                if(testInfo.getUserId().equals(user_id)){
                    test_times++;
                    test_success += testInfo.getSuccess();
                    test_failure += testInfo.getFailure();
                    test_concurrency_count += testInfo.getSuccess();
                    test_concurrency_count += testInfo.getFailure();
                }
            }
            //遍历devInfo中的pipeline信息
            List<PipelineInfo> pipelineInfos = devcloudInfo.getPipelineList();
            for(PipelineInfo pipelineInfo : pipelineInfos){
                //遍历每个流水线中的部署记录
                List<RecordInfo> recordInfos = pipelineInfo.getRecordList();
                for(RecordInfo recordInfo : recordInfos){
                    if(recordInfo.getUserId().equals(user_id)){
                        pipeline_deploy++;
                        if(recordInfo.getResult().equals("部署成功")){
                            pipeline_pass++;
                        }
                        if(recordInfo.getResult().equals("部署失败")){
                            pipeline_failure++;
                        }
                    }
                }
            }
        }

        //commit
        commit.setCommit_times(commit_times);
        commit.setValid_commit_times(valid_commit_time);
        commit.setBuglist_commit(buglist_commit);
        commit.setFeature_commit(feature_commit);
        commit.setCommit_msg_overview(commit_msg_overview);
        //test
        test.setTest_times(test_times);
        test.setTest_concurrency_count(test_concurrency_count);
        test.setTest_concurrency_success(test_success);
        test.setTest_concurrency_failure(test_failure);
        //pipeline
        pipeline.setPipeline_deploy(pipeline_deploy);
        pipeline.setPipeline_pass(pipeline_pass);
        pipeline.setPipline_failure(pipeline_failure);

        formatStudent.setCommit(commit);
        formatStudent.setTest(test);
        formatStudent.setPipeline(pipeline);

        return formatStudent;
    }

    @Override
    public FormatGroup getGroupAnalysis(Integer project_id){
        //暂时不存在GroupId，先使用ProjectId代替
        FormatGroup formatGroup = new FormatGroup();
        Integer projectAId = project_id;
        Integer projectBId = projectRelateDao.findById(project_id).get().getRelateId();

        List<Integer> projectList = new ArrayList<>();
        projectList.add(projectAId);
        projectList.add(projectBId);
        List<Project> projects = new ArrayList<>();
        projects.add(projectDao.findById(projectAId).get());
        projects.add(projectDao.findById(projectBId).get());

        List<Integer> userIds = devcloudProjectDao.findById(project_id).get().getUserIds();

        List<User> users = new ArrayList<>();
        for(int i=0;i<userIds.size();i++){
            Integer userId = userIds.get(i);
            users.add(userDao.findByUserId(userId));
        }
        int n = userIds.size();
//        System.out.println("n: "+n);

        formatGroup.setProjects(projects);
        formatGroup.setStudents(users);

        //放入小组Commit信息，测试信息，流水线信息
        Commit commit = new Commit();
        Test test = new Test();
        Pipeline pipeline = new Pipeline();

        Integer commit_times=0,valid_commit_time=0,buglist_commit=0,feature_commit=0;
        //记录小组不同成员的commit贡献
        int[] commitTimes = new int[n];
        List<String> commit_msg_overview = new ArrayList<>();
        Integer test_success=0,test_failure=0,test_times=0,test_concurrency_count=0;
        //记录小组不同成员的test贡献
        int[] testTimes = new int[n];
        Integer pipeline_deploy=0,pipeline_pass=0,pipeline_failure=0;
        //记录小组不同成员的deploy贡献
        int[] pipeTimes = new int[n];

        //
        for(int i=0;i<projects.size();i++){
            Integer projectId = projectList.get(i);
            DevcloudInfo devcloudInfo = devcloudInfoDao.findById(projectId).get();

            //遍历devInfo中的commit信息
            List<CommitInfo> commitInfos = devcloudInfo.getCommitList();
//            System.out.println("commitInfosSize: "+commitInfos.size());
            commit_times += commitInfos.size();
            for(CommitInfo commitInfo : commitInfos){
                for(int j=0;j<userIds.size();j++){
                    Integer user_id = userIds.get(j);
                    if(commitInfo.getUserId().equals(user_id)){
                        commitTimes[j]++;
                        commit_msg_overview.add(commitInfo.getMessage());
                        //如果是需求的commit
                        if(commitInfo.getType().toLowerCase().equals("tree_id")){
                            feature_commit++;
                        }
                        //如果是bug_list的commit
                        if(commitInfo.getType().toLowerCase().equals("bug_id")){
                            buglist_commit++;
                        }
                        //判断是否是有效的commit
                        if(commitInfo.getMessage().startsWith("feat:")||commitInfo.getMessage().startsWith("fix:")){
                            valid_commit_time++;
                        }
                    }
                }
            }
            //遍历devInfo中的test信息
            List<TestInfo> testInfos = devcloudInfo.getTestList();
            test_times += testInfos.size();
            for(TestInfo testInfo : testInfos){
                for(int j=0;j<userIds.size();j++){
                    Integer user_id = userIds.get(j);
                    if(testInfo.getUserId().equals(user_id)){
                        testTimes[j]++;
                        test_success += testInfo.getSuccess();
                        test_failure += testInfo.getFailure();
                        test_concurrency_count += testInfo.getSuccess();
                        test_concurrency_count += testInfo.getFailure();
                    }
                }
            }
            //遍历devInfo中的pipeline信息
            List<PipelineInfo> pipelineInfos = devcloudInfo.getPipelineList();
            for(PipelineInfo pipelineInfo : pipelineInfos){
                //遍历每个流水线中的部署记录
                List<RecordInfo> recordInfos = pipelineInfo.getRecordList();
                for(int j=0;j<userIds.size();j++){
                    Integer user_id = userIds.get(j);
                    for(RecordInfo recordInfo : recordInfos){
                        if(recordInfo.getUserId().equals(user_id)){
                            pipeline_deploy++;
                            pipeTimes[j]++;
                            if(recordInfo.getResult().equals("部署成功")){
                                pipeline_pass++;
                            }
                            if(recordInfo.getResult().equals("部署失败")){
                                pipeline_failure++;
                            }
                        }
                    }
                }
            }
        }

        DecimalFormat df = new DecimalFormat("#.00");
        //commit
        commit.setCommit_times(commit_times);
        commit.setValid_commit_times(valid_commit_time);
        commit.setBuglist_commit(buglist_commit);
        commit.setFeature_commit(feature_commit);
        commit.setCommit_msg_overview(commit_msg_overview);
        List<Contribution> commitContribution = new ArrayList<>();
        for(int i=0;i<userIds.size();i++){
            Contribution contribution = new Contribution();
            contribution.setName(users.get(i).getName());
            contribution.setTimes(commitTimes[i]);
            Double value;
            if(commit_times == 0){
                value = 0.0;
            }else {
                value = (double)commitTimes[i]/(double)commit_times;
            }
            contribution.setProportion(Double.valueOf(df.format(value)));
            commitContribution.add(contribution);
        }
        commit.setCommit_contribution(commitContribution);
        //test
        test.setTest_times(test_times);
        test.setTest_concurrency_count(test_concurrency_count);
        test.setTest_concurrency_success(test_success);
        test.setTest_concurrency_failure(test_failure);
        List<Contribution> testContribution = new ArrayList<>();
        for(int i=0;i<userIds.size();i++){
            Contribution contribution = new Contribution();
            contribution.setName(users.get(i).getName());
            contribution.setTimes(testTimes[i]);
            Double value;
            if(test_times == 0){
                value = 0.0;
            }else {
                value = (double)testTimes[i]/(double)test_times;
            }
            contribution.setProportion(Double.valueOf(df.format(value)));
            testContribution.add(contribution);
        }
        test.setTest_contribution(testContribution);
        //pipeline
        pipeline.setPipeline_deploy(pipeline_deploy);
        pipeline.setPipeline_pass(pipeline_pass);
        pipeline.setPipline_failure(pipeline_failure);
        List<Contribution> deployContribution = new ArrayList<>();
        for(int i=0;i<userIds.size();i++){
            Contribution contribution = new Contribution();
            contribution.setName(users.get(i).getName());
            contribution.setTimes(pipeTimes[i]);
            Double value;
            if(pipeline_deploy == 0){
                value = 0.0;
            }else {
                value = (double)pipeTimes[i]/(double)pipeline_deploy;
            }
            contribution.setProportion(Double.valueOf(df.format(value)));
            deployContribution.add(contribution);
        }
        pipeline.setPipeline_contribution(deployContribution);

        formatGroup.setCommit(commit);
        formatGroup.setTest(test);
        formatGroup.setPipeline(pipeline);

        return formatGroup;
    }

}