code....

  public IntegrateScoreDto getIntegrateScoreDto(User user, Integer commonLesson) throws JsonProcessingException {
    
        IntegrateScoreDto integrateScoreDto = new IntegrateScoreDto();

        Double grade = getOneStudentAllSemesterAverageGrade(user.getUsername(), user.getMajor(), user.getGrade(), commonLesson);
        Double averageGpa = getOneStudentAllSemesterAverageGpa(user.getUsername(), user.getMajor(), user.getGrade(), commonLesson);
        DecimalFormat df = new DecimalFormat("##.##");
        BigDecimal b = new BigDecimal(averageGpa);
        double f1 = b.setScale(2, RoundingMode.HALF_UP).doubleValue();
        integrateScoreDto.setAverageGpa(df.format(f1));
        integrateScoreDto.setTheStuAverage(df.format(grade));

        integrateScoreDto.setAverageScoreInMajor(df.format(getAllSemesterAverageInMajor(user.getMajor(), user.getGrade(), commonLesson)));
        List<Double> allStuAverageScore = new ArrayList<>();
        //getStuJpaAndScoreRankAllSemesterInMajor
        List<Grade> gradeList = new ArrayList<>();
        if (commonLesson == 1) {
    
            gradeList = gradeService.list(new LambdaQueryWrapper<Grade>().eq(Grade::getMajor, user.getMajor()).eq(Grade::getYear, user.getGrade()).eq(Grade::getCommonLesson, commonLesson));// The grades of all subjects of this major in this grade 
        } else {
    
            gradeList = gradeService.list(new LambdaQueryWrapper<Grade>().eq(Grade::getMajor, user.getMajor()).eq(Grade::getYear, user.getGrade()));
        }
        List<String> userNames = new ArrayList<>();
        List<String> semesters = new ArrayList<>();
        for (Grade grade1 : gradeList) {
    
            if (!semesters.contains(grade1.getSemester())) {
    
                semesters.add(grade1.getSemester());
            }
        }
        for (Grade grade1 : gradeList) {
    
            if (!userNames.contains(grade1.getUsername())) {
    
                userNames.add(grade1.getUsername());
            }
        }
        for (String userName : userNames) {
    
            allStuAverageScore.add(getOneStudentAllSemesterAverageGrade(userName, user.getMajor(), user.getGrade(), commonLesson));

        }
        Collections.sort(allStuAverageScore, new Comparator<Double>() {
    
            @Override
            public int compare(Double o1, Double o2) {
    
                if (o1 < o2) {
    
                    return 1;
                } else if (o1 > o2) {
    
                    return -1;
                }
                return 0;

            }
        });
        integrateScoreDto.setTotal(allStuAverageScore.size());
        integrateScoreDto.setTopScore(df.format(allStuAverageScore.get(0)));

        for (int i = 0; i < allStuAverageScore.size(); i++) {
    
            integrateScoreDto.setTopTenScore(df.format(allStuAverageScore.get(i)));
            if (allStuAverageScore.get(i).equals(grade)) {
    
                integrateScoreDto.setScoreRank(i + 1);

            }
        }
        Integer total =1+ getTotalTopTenInMajor(user.getMajor(),user.getGrade());
        if (allStuAverageScore.size() >= total) {
    
            integrateScoreDto.setTopTenScore(df.format(allStuAverageScore.get(total-1)));
        }

        HashMap<String, JpaAndScore> scoreMap = new HashMap<>();
        HashMap<String, List<GradeAndDetailRank>> detailRank = new HashMap<>();
        List<JpaAndScore> semesterJpaAndScoreRank = new ArrayList<>();
        List<SemesterGradeAndDetail> gradeRankList = new ArrayList<>();
        for (String semester : semesters) {
    
            SemesterGradeAndDetail semesterGradeAndDetail = new SemesterGradeAndDetail();
            JpaAndScore jpaAndScore = new JpaAndScore();
            jpaAndScore.setSemester(semester);
            semesterGradeAndDetail.setSemester(semester);
            List<String> subjectsName = new ArrayList<>();
            List<Grade> theSemesterGradeList = new ArrayList<>();
            if (commonLesson == 1) {
    
                theSemesterGradeList = gradeService.list(new LambdaQueryWrapper<Grade>()
                        .eq(Grade::getSemester, semester).eq(Grade::getMajor, user.getMajor()).eq(Grade::getYear, user.getGrade()).eq(Grade::getCommonLesson, commonLesson));
            } else {
    
                theSemesterGradeList = gradeService.list(new LambdaQueryWrapper<Grade>()
                        .eq(Grade::getSemester, semester).eq(Grade::getMajor, user.getMajor()).eq(Grade::getYear, user.getGrade()));
            }
            for (Grade grade1 : theSemesterGradeList) {
    

                subjectsName.add(grade1.getName());

            }
            jpaAndScore = getStuJpaAndScoreRankInMajor(user.getUsername(), semester, user.getMajor(), user.getGrade(), commonLesson);
            semesterJpaAndScoreRank.add(jpaAndScore);
            List<GradeAndDetailRank> gradeDetailRankInSemester = new ArrayList<>();
            for (int i = 0; i < subjectsName.size(); i++) {
    
                GradeAndDetailRank gradeAndDetailRank = new GradeAndDetailRank();
                gradeAndDetailRank.setSubjectName(subjectsName.get(i));


                gradeAndDetailRank.setGradeRankList(getDetailGrades(user, user.getMajor(), subjectsName.get(i), semester));
                gradeDetailRankInSemester.add(gradeAndDetailRank);
                semesterGradeAndDetail.setGradeAndDetailRank(gradeAndDetailRank);
            }
            gradeRankList.add(semesterGradeAndDetail);
            // detailRank.put(semester,gradeDetailRankInSemester);


        }
        //integrateScoreDto.setGradeRankList(gradeRankList);
        integrateScoreDto.setSemesterJpaAndScoreRank(semesterJpaAndScoreRank);
        return integrateScoreDto;
    }

    @ApiOperation(" All score information integration interfaces ")
    @GetMapping("/getOneStuIntegrateScore")
    public Result getIntegrateScore(@RequestParam("ticket") String ticket,
                                    @RequestParam("username") String username,
                                    @RequestParam("commonLesson")
                                   @ApiParam(" Whether the ranking of public elective courses is included ,0 The representative contains ,1 Does not include ")Integer commonLesson
                                 ) throws JsonProcessingException {
    
        JSONObject json = JSON.parseObject(commonClient.getInfo(ticket));
        JSONObject info = json.getJSONArray("cultivateTypeList").getJSONObject(0);
        String requestUserName = info.getString("code");
        if (!requestUserName.equals(username)) {
    
            return Result.fail(402, " Please log in to your account again !", null);
        }

        User user = userServiceImpl.getOne(new LambdaQueryWrapper<User>().eq(User::getUsername, username));

        IntegrateScoreDto integrateScoreDto = rankService.getIntegrateScoreDto(user,commonLesson);


        return Result.success(integrateScoreDto);

    }