moooc_review/src/main/java/com/mooctest/controller/ReportController.java

package com.mooctest.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.hankcs.hanlp.seg.Segment;
import com.hankcs.hanlp.seg.common.Term;
import com.mooctest.data.BugDTO;
import com.mooctest.data.FinalReportDTO;
import com.mooctest.data.SupplementDTO;
import com.mooctest.data.TaskDTO;
import com.mooctest.model.BugData;
import com.mooctest.model.MasterReport;
import com.mooctest.service.*;
import com.mooctest.util.NLPUtil;
import com.mooctest.util.ReportUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.aggregation.ArrayOperators;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.ResourceUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toMap;

@Controller
public class ReportController {

    @Autowired
    SupplementService supplementService;

    @Autowired
    BugReportService bugReportService;

    @Autowired
    MasterReportService masterReportService;

    @Autowired
    FinalReportService finalReportService;

    @Autowired
    BugReviewService bugReviewService;

    @Autowired
    TaskService taskService;

    @Autowired
    HistoryService historyService;

    @Autowired
    BugDataService bugDataService;

    @GetMapping(value = "/index")
    public String hello(HttpServletRequest request, @RequestParam(value = "name", required = false, defaultValue = "springboot-thymeleaf") String name) {
        request.setAttribute("name", name);
        return "index";
    }



    //聚合报告
    @GetMapping(value = "/report")
    public String showAggrReport(@RequestParam("masterId") String masterId,
                                 @RequestParam("examId") long examId,
                                 @RequestParam("caseId") long caseId,
                                 @RequestParam(value = "finalReportId", required = false) Long finalReportId,
                                 Model model) {
        Map<String, BugDTO> bugMap = bugReportService.getAllBugsMap(examId, caseId);//得到所有的报告信息
        BugDTO masterReport = bugMap.get(masterId); // 得到主报告
        List<SupplementDTO> supplements = supplementService.getSupplementByMasterId(masterId, bugMap); // 补充点报告
        List<BugDTO> bugs = new LinkedList<>();
        bugs.add(masterReport);
        supplements.forEach(supplementDTO -> bugs.addAll(supplementDTO.getBugs()));
        Collection<BugDTO> distinctBugs = bugs.stream().collect(Collectors.toMap(BugDTO::getId,Function.identity(),(v1,v2)->v1)).values();
//        List<BugDTO> sourceReports = distinctBugs.stream().distinct().collect(Collectors.toList());
        // 各种类型的报告数量的统计，
        Map<String, Long> categoryCounts = distinctBugs.stream().collect(Collectors.groupingBy(BugDTO::getBugCategory, Collectors.counting()));
        Map<String, Long> pageCounts =  distinctBugs.stream().filter(e->e.getBug_page()!=null).collect(Collectors.groupingBy(BugDTO::getBug_page,Collectors.counting()));
        Map<String, Long> recurrentCounts = distinctBugs.stream()
                .map(BugDTO::getRecurrent)
                .map((recurrentNum) -> ReportUtil.recurrent2String.get(recurrentNum))
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        Map<String, Long> severityCounts = distinctBugs.stream()
                .map(BugDTO::getSeverity)
                .map((severityNum) -> ReportUtil.severity2String.get(severityNum))
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        //得到创建的final report
        List<FinalReportDTO> finalReports = finalReportService.getBySourceId(masterId);
        Map<String,String> single2rootMap = historyService.getSingle2Root(caseId, examId);
        model.addAttribute("single2root",single2rootMap);
//        model.addAttribute("wordList", getWordCloudList(sourceReports));
        model.addAttribute("categoryCounts", categoryCounts);
        model.addAttribute("severityCounts", severityCounts);
        model.addAttribute("pageCounts",pageCounts);
        model.addAttribute("recurrentCounts",recurrentCounts);
        model.addAttribute("aggReportId", "ML-AG-" + masterId.substring(10));
        model.addAttribute("masterReport", masterReport);
        model.addAttribute("createTime", new Date(Long.parseLong(masterReport.getCreateTimeMillis())));
        model.addAttribute("supplements", supplements);
        model.addAttribute("finalReports", finalReports);
        model.addAttribute("category2String", ReportUtil.category2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
//        model.addAttribute("show")

        model.addAttribute("showReference",true);//是否展示其他聚合报告的参考标签
        boolean bugReviewed = bugReviewService.isBugReviewed(masterId);

        model.addAttribute("reviewed", bugReviewed);
        if (finalReportId != null) {
            Optional<FinalReportDTO> finalReportDTO = finalReports.stream().filter(finalReport -> finalReport.getId()==finalReportId).findFirst();
            model.addAttribute("finalReportId", finalReportId);
            model.addAttribute("editReport", finalReportDTO.get());
        }
        return "agg_report_new";
    }

    //part of aggreate report  为了在树状报告页面展示聚合报告信息
    @GetMapping(value = "/report_part")
    public String showAggrReportPart(@RequestParam("masterId") String masterId,
                                     @RequestParam("examId") long examId,
                                     @RequestParam("caseId") long caseId,
                                     @RequestParam(value = "finalReportId", required = false) Long finalReportId,
                                     Model model) {
        Map<String, BugDTO> bugMap = bugReportService.getAllBugsMap(examId, caseId);
        BugDTO masterReport = bugMap.get(masterId);
        List<SupplementDTO> supplements = supplementService.getSupplementByMasterId(masterId, bugMap);
        List<BugDTO> bugs = new LinkedList<>();
        supplements.forEach(supplementDTO -> bugs.addAll(supplementDTO.getBugs()));
        List<BugDTO> sourceReports = bugs.stream().distinct().collect(Collectors.toList());
        Map<String, Long> categoryCounts = sourceReports.stream().collect(Collectors.groupingBy(BugDTO::getBugCategory, Collectors.counting()));
        Map<String, Long> pageCounts =  sourceReports.stream().collect(Collectors.groupingBy(BugDTO::getBug_page,Collectors.counting()));
        Map<String, Long> recurrentCounts = sourceReports.stream()
                .map(BugDTO::getRecurrent)
                .map((recurrentNum) -> ReportUtil.recurrent2String.get(recurrentNum))
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        Map<String, Long> severityCounts = sourceReports.stream()
                .map(BugDTO::getSeverity)
                .map((severityNum) -> ReportUtil.severity2String.get(severityNum))
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        List<FinalReportDTO> finalReports = finalReportService.getBySourceId(masterId);
        Map<String,String> single2rootMap = historyService.getSingle2Root(caseId, examId);
        model.addAttribute("single2root",single2rootMap);
//        model.addAttribute("wordList", getWordCloudList(sourceReports));
        model.addAttribute("categoryCounts", categoryCounts);
        model.addAttribute("severityCounts", severityCounts);
        model.addAttribute("pageCounts",pageCounts);
        model.addAttribute("recurrentCounts",recurrentCounts);
        model.addAttribute("aggReportId", "ML-AG-" + masterId.substring(10));
        model.addAttribute("masterReport", masterReport);
        model.addAttribute("createTime", new Date(Long.parseLong(masterReport.getCreateTimeMillis())));
        model.addAttribute("supplements", supplements);
        model.addAttribute("finalReports", finalReports);
        model.addAttribute("category2String", ReportUtil.category2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
        model.addAttribute("showReference",false);//是否展示其他聚合报告的参考标签
        boolean bugReviewed = bugReviewService.isBugReviewed(masterId);
        model.addAttribute("reviewed", bugReviewed);
        if (finalReportId != null) {
            Optional<FinalReportDTO> finalReportDTO = finalReports.stream().filter(finalReport -> finalReport.getId()==finalReportId).findFirst();
            model.addAttribute("finalReportId", finalReportId);
            model.addAttribute("editReport", finalReportDTO.get());
        }
        return "agg_report_new::masterBody";
    }

    /**
     * 单个报告的展示页面，
     * @param id
     * @param examId
     * @param caseId
     * @param model
     * @return
     */
    @GetMapping(value = "/report/{id}")
    public String showAggrReportTest(@PathVariable("id") String   id,
                                     @RequestParam("examId") long examId,
                                     @RequestParam("caseId") long caseId,
                                     Model model) {
        BugDTO singleReport = bugReportService.getBugById(id,examId, caseId); // 具体的bug的DTO
        MasterReport masterReportSource = masterReportService.getByBugId(id+""); // 找到该报告的master报告报告；
        List<FinalReportDTO> finalReports =new ArrayList<>();
        Map<String,String> sing2root = historyService.getSingle2Root(caseId, examId);
        String treeReportId = sing2root.get(id);
        finalReports.addAll(finalReportService.getBySourceId(id));
        if(masterReportSource == null){// 如果不存在聚合报告;
            model.addAttribute("hasMaster",false);
        }else{
            model.addAttribute("hasMaster",true);
            String masterId = masterReportSource.getMasterId();
            addDistinctFinalReport(finalReports,finalReportService.getBySourceId(masterId));
            StringBuffer masterName = new StringBuffer("ML-AG-");
            masterName.append(masterId.substring(10));
            model.addAttribute("masterName",masterName.toString());
            StringBuffer masterUrl = new StringBuffer("/report?masterId=");
            masterUrl.append(masterId).append("&examId=").append(examId).append("&caseId=").append(caseId);
            model.addAttribute("masterUrl",masterUrl.toString());
        }
        if(treeReportId == null){
            //如果不存在树状报告
            model.addAttribute("hasTree",false);
        }else{
            model.addAttribute("hasTree",true);
            addDistinctFinalReport(finalReports,finalReportService.getBySourceId(treeReportId));
            model.addAttribute("treeName","ML-TR-"+getShortId(treeReportId));
            model.addAttribute("treeUrl","/history/report?treeId="+treeReportId+"&examId="+examId+"&caseId="+caseId);
        }
        model.addAttribute("singleReport",singleReport);
        model.addAttribute("reviewed",bugDataService.isReviewed(id));
        model.addAttribute("createTime", new Date(Long.parseLong(singleReport.getCreateTimeMillis())));
        model.addAttribute("finalReports", finalReports);
        model.addAttribute("category2String", ReportUtil.category2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
        model.addAttribute("reportId",id);
        return "single_report";
    }



    private String getShortId ( String input ){
        return input.length()<10?input:input.substring(input.length()-10);
    }

    @GetMapping("editReportData")
    @ResponseBody
    public FinalReportDTO getEditReportData(@RequestParam("masterId") String masterId,
                                            @RequestParam(value = "finalReportId", required = false) Long finalReportId,
                                            Model model){
        List<FinalReportDTO> finalReports = finalReportService.getBySourceId(masterId);
        Optional<FinalReportDTO> finalReportDTO = finalReports.stream().filter(finalReport -> finalReport.getId()==finalReportId).findFirst();
        return finalReportDTO.get();
    }

    //报告列表
    @GetMapping("created_reports")
    public String getCreatedReports(@RequestParam("masterId") String masterId,
                                    @RequestParam("examId") long examId,
                                    @RequestParam("caseId") long caseId,Model model){
        List<FinalReportDTO> finalReports = finalReportService.getBySourceId(masterId);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
        model.addAttribute("finalReports", finalReports);
        model.addAttribute("category2String", ReportUtil.category2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        return "agg_report_new::ul_reports";
    }

    //报告列表
    @GetMapping("created_reports_single")
    public String getCreatedReportsSingle(@RequestParam("masterId") String masterId,
                                    @RequestParam("examId") long examId,
                                    @RequestParam("caseId") long caseId,Model model){
        List<FinalReportDTO> finalReports = finalReportService.getBySourceId(masterId);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
        model.addAttribute("finalReports", finalReports);
        model.addAttribute("category2String", ReportUtil.category2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        return "single_report::ul_reports";
    }

    //创建报告界面
    @GetMapping("created_reports_form")
    public String getCreatedReportssd(Model model){
        model.addAttribute("category2String", ReportUtil.category2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        return "agg_report_new::create_reports";
    }

    private String getWordCloudList(List<BugDTO> sourceReports) {
        Map<String, Integer> wordCount = new HashMap<>();
        Set<String> stopWords = new HashSet<>();
        try {
            File file = ResourceUtils.getFile("classpath:stopwords.txt");
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String line;
            while ((line = reader.readLine()) != null) {
                stopWords.add(line.trim());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        sourceReports.forEach((bug) -> {
            Segment seg = NLPUtil.getDefaultSegment();
            List<Term> terms = seg.seg(bug.getDescription());
            for (Term term : terms) {
                if (stopWords.contains(term.word)) {
                    continue;
                }
                if (wordCount.get(term.word) == null) {
                    wordCount.put(term.word, 1);
                    continue;
                }
                int count = wordCount.get(term.word);
                wordCount.put(term.word, ++count);
            }
        });
        JSONArray wordList = new JSONArray();
        wordCount.forEach((word, count) -> {

            if (word.length() > 1) {

                JSONObject wordObj = new JSONObject();
                wordObj.fluentPut("text", word)
                        .fluentPut("weight", count * 10);
                wordList.add(wordObj);
            }

        });

        return wordList.toJSONString();
    }

    //审核报告；
    @GetMapping(value = "agg_report_list")
    public String showAggReportList(@RequestParam("examId") long examId,
                                    @RequestParam("caseId") long caseId,
                                    @RequestParam(value = "status", required = false, defaultValue = "-1") int status,
                                    Model model) {
        List<String> masterIds = masterReportService.getAllMasterIdByExamIdAndCaseId(examId, caseId);//get all masterreport id String
        List<BugData> bugDatas = bugDataService.getBugDataByIds(masterIds);
        Map<String,BugData> bugDataMap = bugDatas.stream().collect(toMap(BugData::getBugId,Function.identity()));
        if (status >= 0) {
            masterIds = masterIds.stream().filter(masterId -> bugDataMap.get(masterId).getStatus() == status).collect(Collectors.toList());
        }
//        Map<String, List<String>> master2BugIdsMap = supplementService.getMaster2BugIdsMap(masterIds);
        Map<String, List<String>> master2BugIdsMap = masterReportService.getMaster2BugIdsMap(masterIds); // master报告对应的report的列表
        Map<String, BugDTO> bugsMap = bugReportService.getAllBugsMap(examId, caseId); //得到所有bug的对应map
//        Map<String, List<BugDTO>> masterBugMap = bugReportService.getMasterBugMap(master2BugIdsMap, bugsMap);
        TaskDTO task = taskService.getByExamIdAndCaseId(examId, caseId); // 任务情况
        masterIds.forEach(masterId -> {
            bugsMap.get(masterId).setStatus(bugDataMap.get(masterId).getStatus());
        });
        model.addAttribute("master2BugIdsMap", master2BugIdsMap);
        model.addAttribute("bugMap", bugsMap);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
        model.addAttribute("task", task);
        model.addAttribute("aggNum", masterReportService.getAggNum(examId, caseId));
        return "agg_report_list";
    }


    @GetMapping(value = "review_report")
    public String showAggReportLisst(@RequestParam("examId") long examId,
                                     @RequestParam("caseId") long caseId,
                                     @RequestParam(value = "status", required = false, defaultValue = "-1") int status,
                                     Model model) {
        boolean aggregated = masterReportService.isAggregated(examId, caseId);
        List<BugDTO> allReports = bugReportService.getAllBugs(examId, caseId);
        TaskDTO task = taskService.getByExamIdAndCaseId(examId, caseId);
        List<String> treeRootids = historyService.getTreeRoots(caseId+"-"+examId);
        Map<String,List<String>> tree2BugIdsMap = historyService.getTree2BugIdsMap(treeRootids);
        Map<String,String> single2rootMap = historyService.getSingle2Root(caseId, examId);
        Map<String , BugData> bugIds2Data = bugDataService.bugId2BugData(examId,caseId) ;
        Map<String, BugDTO> bugsMap = bugReportService.getAllBugsMap(examId, caseId);
        List<String> bugIds = allReports.stream().map(BugDTO::getId).collect(Collectors.toList());
        if (aggregated) { // 如果报告已经是聚合过的。
            List<MasterReport> mrs = masterReportService.getByBugIds(bugIds);
            Map<String, MasterReport> mrMap = mrs.stream().collect(toMap(MasterReport::getBugId, Function.identity()));
            allReports.forEach(bug -> {
                bug.setMasterId(mrMap.get(bug.getId()).getMasterId());
            });
            List<String> masterIds = masterReportService.getAllMasterIdByExamIdAndCaseId(examId, caseId);
            List<MasterReport> mrs0 = masterReportService.getByBugIds(masterIds);
            Map<String, MasterReport> mrMap0 = mrs0.stream().collect(toMap(MasterReport::getBugId, Function.identity()));
            if (status >= 0) {
                masterIds = masterIds.stream().filter(masterId -> mrMap0.get(masterId).getStatus() == status).collect(Collectors.toList());
            }
            Map<String, List<String>> master2BugIdsMap = masterReportService.getMaster2BugIdsMap(masterIds);
            model.addAttribute("master2BugIdsMap", master2BugIdsMap); // 聚合才有的
            model.addAttribute("aggNum", masterReportService.getAggNum(examId, caseId)); // 聚合才有的
        }
        bugIds.forEach(id -> {
            bugsMap.get(id).setStatus(bugIds2Data.get(id).getStatus());
        });
        allReports.forEach(bug -> {
            bug.setStatus(bugIds2Data.get(bug.getId()).getStatus());
            bug.setReviewerId(bugIds2Data.get(bug.getId()).getReviewerId());
            String te = single2rootMap.get(bug.getId());
            bug.setTreeId(te==null?"null":te);
        });
        model.addAttribute("bugMap", bugsMap);// 聚合才有de
        model.addAttribute("treeNum",treeRootids.size());
        model.addAttribute("tree2BugIdsMap",tree2BugIdsMap);
        model.addAttribute("aggregated", aggregated);
        model.addAttribute("allReports", allReports);
        model.addAttribute("severity2String", ReportUtil.severity2String);
        model.addAttribute("recurrent2String", ReportUtil.recurrent2String);
        model.addAttribute("reviewMap", ReportUtil.reviewerMap);
        model.addAttribute("task", task);
        model.addAttribute("examId", examId);
        model.addAttribute("caseId", caseId);
        return "all_review_report";
    }

    private void addDistinctFinalReport( List<FinalReportDTO>source , List<FinalReportDTO> adds ){
        List<FinalReportDTO> shouldAdds = new ArrayList<>();
        for(FinalReportDTO d : adds){
            boolean flag = true;
            for(FinalReportDTO x : source){
                if( x.getId() == d.getId()){
                    flag = false;
                    break ;
                }
            }
            if(flag){
                shouldAdds.add(d);
            }
        }
        source.addAll(shouldAdds);
    }
}