api/src/main/java/com/xjrsoft/module/evaluate/service/impl/EvaluateResultServiceImpl.java

package com.xjrsoft.module.evaluate.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.EnabledMark;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.mybatis.SqlRunnerAdapter;
import com.xjrsoft.common.page.ConventPage;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.evaluate.dto.AddEvaluateResultDto;
import com.xjrsoft.module.evaluate.dto.EvaluateResultDetailPageDetailDto;
import com.xjrsoft.module.evaluate.dto.EvaluateResultDetailPageDto;
import com.xjrsoft.module.evaluate.dto.EvaluateResultIndexPageDto;
import com.xjrsoft.module.evaluate.dto.EvaluateResultSaveDto;
import com.xjrsoft.module.evaluate.dto.ResultViewingPageDto;
import com.xjrsoft.module.evaluate.entity.EvaluateExecuter;
import com.xjrsoft.module.evaluate.entity.EvaluateManage;
import com.xjrsoft.module.evaluate.entity.EvaluateManageItem;
import com.xjrsoft.module.evaluate.entity.EvaluateObject;
import com.xjrsoft.module.evaluate.entity.EvaluateResult;
import com.xjrsoft.module.evaluate.entity.EvaluateSubmitRecord;
import com.xjrsoft.module.evaluate.mapper.EvaluateExecuterMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateManageItemMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateObjectMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateResultMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateSubmitRecordMapper;
import com.xjrsoft.module.evaluate.service.IEvaluateResultService;
import com.xjrsoft.module.evaluate.vo.EvaluateResultDetailPageDetailVo;
import com.xjrsoft.module.evaluate.vo.EvaluateResultDetailPageVo;
import com.xjrsoft.module.evaluate.vo.EvaluateResultIndexPageVo;
import com.xjrsoft.module.evaluate.vo.MobileResultPageVo;
import com.xjrsoft.module.evaluate.vo.ResultViewingListVo;
import com.xjrsoft.module.evaluate.vo.ResultViewingPageVo;
import com.xjrsoft.module.teacher.entity.XjrUser;
import lombok.AllArgsConstructor;
import me.zhyd.oauth.log.Log;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.ByteArrayOutputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @title: 评价结果
 * @Author szs
 * @Date: 2024-01-16
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class EvaluateResultServiceImpl extends MPJBaseServiceImpl<EvaluateResultMapper, EvaluateResult> implements IEvaluateResultService {

    private EvaluateObjectMapper evaluateObjectMapper;

    private EvaluateResultMapper evaluateResultMapper;

    private EvaluateManageItemMapper evaluateManageItemMapper;

    private EvaluateSubmitRecordMapper evaluateSubmitRecordMapper;

    private EvaluateExecuterMapper evaluateExecuterMapper;

    @Override
    public IPage<EvaluateResultIndexPageVo> getIndexPage(EvaluateResultIndexPageDto dto) {
        IPage<EvaluateResultIndexPageVo> page = evaluateResultMapper.getIndexPage(ConventPage.getPage(dto), dto);
        return page;
    }

    @Override
    public IPage<EvaluateResultDetailPageVo> getDetailPage(EvaluateResultDetailPageDto dto) {
        //获取当前评价管理下的所有记录的page
        IPage<EvaluateResultDetailPageVo> page = evaluateResultMapper.getDetailPage(ConventPage.getPage(dto), dto);
        return page;
    }

    @Override
    public EvaluateResultDetailPageDetailVo getDetailPageDetail(EvaluateResultDetailPageDetailDto dto) {
        //根据评价管理主键编号，被评对象id，执行人id获取总得分，被评对象名字，执行人名字,评价管理名字，题目满分
        EvaluateResultDetailPageDetailVo evaluateResultDetailPageDetailVo = evaluateResultMapper.getDetailPageDetail(dto);

        if (evaluateResultDetailPageDetailVo == null) {
            return evaluateResultDetailPageDetailVo;
        }

        //获取list
        evaluateResultDetailPageDetailVo.setEvaluateResultDetailPageDetailList(evaluateResultMapper.getDetailPageDetailList(dto));
        return evaluateResultDetailPageDetailVo;
    }

    @Override
    public List<ResultViewingPageVo> pageResultViewing(ResultViewingPageDto dto) {
        List<ResultViewingPageVo> resultData = new ArrayList<>();
        //获取该评价管理下的被评对象-分页
        MPJLambdaWrapper<EvaluateObject> evaluateObjectMPJLambdaWrapper = new MPJLambdaWrapper<>();
        evaluateObjectMPJLambdaWrapper
                .distinct()
                .selectAs(EvaluateObject::getObjectId, ResultViewingPageVo::getObjectId)
                .select("ifnull(t1.name, t2.name) as objectIdCN")
                .leftJoin(XjrUser.class, XjrUser::getId, EvaluateObject::getObjectId)
                .leftJoin(BaseClass.class, BaseClass::getId, EvaluateObject::getObjectId)
                .eq(EvaluateObject::getEvaluateManageId, dto.getEvaluateManageId())
                .eq((dto.getBaseGradeId() != null && dto.getBaseGradeId() > 0), BaseClass::getGradeId, dto.getBaseGradeId())
                .eq((dto.getClassId() != null && dto.getClassId() > 0), BaseClass::getId, dto.getClassId())
                .eq(ObjectUtil.isNotNull(dto.getTeacherId()), EvaluateObject::getObjectId, dto.getTeacherId())
                .like((dto.getName() != null && !("").equals(dto.getName())), XjrUser::getName, dto.getName())
                .disableSubLogicDel();
        List<ResultViewingPageVo> list = evaluateObjectMapper.selectJoinList(ResultViewingPageVo.class, evaluateObjectMPJLambdaWrapper);
        //被评对象的id集合
        List<Long> evaluateObjectIdList = new ArrayList<>();
        for (ResultViewingPageVo resultViewingPageVo : list) {
            evaluateObjectIdList.add(resultViewingPageVo.getObjectId());
        }

        //获取该评价管理下的所有题目-多个
        MPJLambdaWrapper<EvaluateManageItem> evaluateManageItemMPJLambdaWrapper = new MPJLambdaWrapper<>();
        evaluateManageItemMPJLambdaWrapper
                .eq(EvaluateManageItem::getEvaluateManageId, dto.getEvaluateManageId());
        List<EvaluateManageItem> evaluateManageItemList = evaluateManageItemMapper.selectList(evaluateManageItemMPJLambdaWrapper);
        //题目的id集合
        //将题目处理成Map
        List<Long> evaluateManageItemIdList = new ArrayList<>();
        Map<Long, EvaluateManageItem> evaluateManageItemMap = new HashMap<>();
        for (EvaluateManageItem evaluateManageItem : evaluateManageItemList) {
            evaluateManageItemIdList.add(evaluateManageItem.getId());
            evaluateManageItemMap.put(evaluateManageItem.getId(), evaluateManageItem);
        }

        //获取该评价管理下的被评对象的应打分人数，实际打分人数
        MPJLambdaWrapper<EvaluateExecuter> evaluateExecuterMPJLambdaWrapper = new MPJLambdaWrapper<>();
        evaluateExecuterMPJLambdaWrapper
                .select(EvaluateExecuter::getId)
                .selectAs(EvaluateObject::getObjectId, ResultViewingPageVo::getObjectId)
                .select(EvaluateExecuter::getStatus)//这里值得推敲
                .leftJoin(EvaluateObject.class, EvaluateObject::getId, EvaluateExecuter::getEvaluateObjectId)
                .eq(EvaluateExecuter::getEvaluateManageId, dto.getEvaluateManageId())
                .in(!evaluateObjectIdList.isEmpty(), EvaluateObject::getObjectId, evaluateObjectIdList)
                .disableSubLogicDel();
        List<ResultViewingPageVo> planAndActualExecuterNum = evaluateExecuterMapper.selectJoinList(ResultViewingPageVo.class, evaluateExecuterMPJLambdaWrapper);
        //将应打分人数，实际打分人数处理成Map
        Map<Long, List<ResultViewingPageVo>> planAndActualExecuterNumMap = planAndActualExecuterNum.stream().filter(x -> x.getStatus() == 2).collect(Collectors.groupingBy(ResultViewingPageVo::getObjectId));
        Map<Long, List<ResultViewingPageVo>> planAndShouldExecuterNumMap = planAndActualExecuterNum.stream().collect(Collectors.groupingBy(ResultViewingPageVo::getObjectId));

        Map<Long, List<ResultViewingPageVo>> groupedByObjectIdList = new HashMap<>();
        //获取该评价管理下的所有被评对象的所有题的总得分
        if (!evaluateManageItemIdList.isEmpty()) {
            List<ResultViewingPageVo> listByObjectIdAndEvaluateItemId =  evaluateResultMapper.listByObjectIdAndEvaluateItemId(evaluateObjectIdList, evaluateManageItemIdList);
            //将所有被评对象的所有题的总得分处理成Map
            groupedByObjectIdList = listByObjectIdAndEvaluateItemId.stream()
                    .collect(Collectors.groupingBy(ResultViewingPageVo::getObjectId));

        }
        List<ResultViewingListVo> resultViewingList = evaluateResultMapper.getResultViewingList(dto);
        //遍历分页记录
        for (ResultViewingPageVo resultViewingPageVo : list) {
            List<ResultViewingPageVo> resultViewingPageVoList = groupedByObjectIdList.get(resultViewingPageVo.getObjectId());
            Map<Long, List<ResultViewingListVo>> itemMaps = resultViewingList.stream().filter(x -> x.getObjectId().equals(resultViewingPageVo.getObjectId()))
                    .collect(Collectors.groupingBy(ResultViewingListVo::getEvaluateManageItemId));
            if(itemMaps.isEmpty()){
                continue;
            }
            if(resultViewingPageVoList != null && !resultViewingPageVoList.isEmpty()){
                for (ResultViewingPageVo r : resultViewingPageVoList) {
                    double v = itemMaps.get(r.getEvaluateManageItemId()).stream().mapToDouble(ResultViewingListVo::getScore).average().orElse(0.0);
                    resultData.add(new ResultViewingPageVo(){{
                        setObjectId(resultViewingPageVo.getObjectId());
                        setObjectIdCN(resultViewingPageVo.getObjectIdCN());
                        setEvaluateManageItemId(r.getEvaluateManageItemId());
                        setProblem(evaluateManageItemMap.get(r.getEvaluateManageItemId()).getProblem());
                        setTopic(evaluateManageItemMap.get(r.getEvaluateManageItemId()).getTopic());
                        setPlanExecuterNum(planAndShouldExecuterNumMap.get(resultViewingPageVo.getObjectId()).size());
                        int actualExecuterNum = planAndActualExecuterNumMap.get(resultViewingPageVo.getObjectId()).size();
                        setActualExecuterNum(actualExecuterNum);
                        setSumScore(BigDecimal.valueOf(v).setScale(2, RoundingMode.HALF_UP).doubleValue() + "");
                    }});
                }
            }
        }

        Map<Long, Double> synthesisScoreMap = resultData.stream().collect(Collectors.groupingBy(ResultViewingPageVo::getObjectId, Collectors.summingDouble(ResultViewingPageVo::getScore)));

        Map<String, Double> itemListMaps = new HashMap<>();
        Map<Long, List<ResultViewingPageVo>> personListMap = resultData.stream().collect(Collectors.groupingBy(ResultViewingPageVo::getObjectId));
        for (Long objectId : personListMap.keySet()) {
            List<ResultViewingPageVo> itemList = personListMap.get(objectId);
            Map<String, Double> itemListMap = itemList.stream().collect(Collectors.groupingBy(ResultViewingPageVo::getTopic, Collectors.summingDouble(ResultViewingPageVo::getScore)));
            for (String topic : itemListMap.keySet()) {
                itemListMaps.put(objectId + "" + topic, itemListMap.get(topic));
            }
        }

        for (ResultViewingPageVo pageVo : resultData) {
            pageVo.setSynthesisScore(BigDecimal .valueOf(synthesisScoreMap.get(pageVo.getObjectId())).setScale(2, RoundingMode.HALF_UP).doubleValue() + "");

            Double itemScore = itemListMaps.get(pageVo.getObjectId() + "" + pageVo.getTopic());
            pageVo.setTopicScore(BigDecimal .valueOf(itemScore).setScale(2, RoundingMode.HALF_UP).doubleValue()+ "");
        }

        return resultData;
    }

    @Override
    @Transactional
    public String saveBatch(EvaluateResultSaveDto dto) {
        Date createDate = new Date();

        //获取当前评价管理的相关信息
        MPJLambdaWrapper<EvaluateSubmitRecord> evaluateSubmitRecordMPJLambdaWrapper = new MPJLambdaWrapper<>();
        evaluateSubmitRecordMPJLambdaWrapper
                .selectAs(EvaluateSubmitRecord::getId, MobileResultPageVo::getEvaluateSubmitRecordId)
                .selectAs(EvaluateSubmitRecord::getEvaluateManageId, MobileResultPageVo::getEvaluateManageId)
                .selectAs(EvaluateSubmitRecord::getEvaluatedObjectId, MobileResultPageVo::getEvaluateObjectId)
                .selectAs(EvaluateSubmitRecord::getEvaluateExecuterId, MobileResultPageVo::getEvaluateUserId)
                .selectAs(EvaluateSubmitRecord::getStatus, MobileResultPageVo::getEvaluateStatus)
                .selectAs(EvaluateSubmitRecord::getEvaluatedObject, MobileResultPageVo::getEvaluateType)
                .selectAs(EvaluateManage::getIsAutoCreate, MobileResultPageVo::getIsAutoCreate)
                .leftJoin(EvaluateManage.class, EvaluateManage::getId, EvaluateSubmitRecord::getEvaluateManageId)
                .eq(EvaluateSubmitRecord::getId, dto.getEvaluateSubmitRecordId());
        MobileResultPageVo mobileResultPageVo = evaluateSubmitRecordMapper.selectJoinOne(MobileResultPageVo.class, evaluateSubmitRecordMPJLambdaWrapper);

        if(mobileResultPageVo == null){
            return "该评价已失效！";
        }

//        if(mobileResultPageVo.getEvaluateStatus() == 2){
//            return "已经评价，请勿重复评价";
//        }

        //评价结果保存
        String delSql = "DELETE FROM evaluate_result WHERE submit_record_id = '" + mobileResultPageVo.getEvaluateSubmitRecordId() + "'";
        SqlRunnerAdapter.db().delete(delSql);

        List<AddEvaluateResultDto> resultList = dto.getResultList();
        for (AddEvaluateResultDto addEvaluateResultDto : resultList) {
            EvaluateResult evaluateResult = BeanUtil.toBean(addEvaluateResultDto, EvaluateResult.class);
            evaluateResult.setEvaluatedObject(mobileResultPageVo.getEvaluateType());
            evaluateResult.setUserId(Long.parseLong(mobileResultPageVo.getEvaluateUserId()));
            evaluateResult.setEvaluatedObjectId(Long.parseLong(mobileResultPageVo.getEvaluateObjectId()));
            evaluateResult.setDeleteMark(DeleteMark.NODELETE.getCode());
            evaluateResult.setEnabledMark(EnabledMark.ENABLED.getCode());
            evaluateResult.setCreateDate(createDate);
            evaluateResult.setSubmitRecordId(mobileResultPageVo.getEvaluateSubmitRecordId());
            evaluateResultMapper.insert(evaluateResult);
        }


        //修改答题人状态
        evaluateExecuterMapper.updateById(new EvaluateExecuter(){{
            setId(Long.parseLong(mobileResultPageVo.getEvaluateUserId()));
            if(dto.getSubmitType() != null && dto.getSubmitType() == 1){
                setStatus(1);
            } else {
                setStatus(2);
            }
        }});

        //修改提交记录状态
        evaluateSubmitRecordMapper.updateById(new EvaluateSubmitRecord(){{
            setId(mobileResultPageVo.getEvaluateSubmitRecordId());
            if(dto.getSubmitType() != null && dto.getSubmitType() == 1){
                setStatus(1);
            } else {
                setStatus(2);
            }
        }});

        return "ok";
    }

    @Override
    public byte[] getList(ResultViewingPageDto dto) {
        try {
            List<ResultViewingPageVo> list = this.pageResultViewing(dto);
            //查询有多少个题目
            MPJLambdaWrapper<EvaluateManageItem> evaluateManageItemMPJLambdaWrapper = new MPJLambdaWrapper<>();
            evaluateManageItemMPJLambdaWrapper
                    .select(EvaluateManageItem::getId)
                    .select(EvaluateManageItem.class, x -> VoToColumnUtil.fieldsToColumns(EvaluateManageItem.class).contains(x.getProperty()))
                    .eq(EvaluateManageItem::getEvaluateManageId, dto.getEvaluateManageId());
            List<EvaluateManageItem> itemList = evaluateManageItemMapper.selectList(evaluateManageItemMPJLambdaWrapper);
            //大题个数
            Map<String, List<EvaluateManageItem>> topicMap = itemList.stream().collect(Collectors.groupingBy(EvaluateManageItem::getTopic));

//        int startRow = 1;
//        List<Map<Integer, Integer>> mergeList = new ArrayList<>();
            Set<Long> objectList = list.stream().map(ResultViewingPageVo::getObjectId).collect(Collectors.toSet());
            Map<Long, Integer> sortCodeMap = new HashMap<>();

            int sortCode = 1;
            for (Long objectId : objectList) {
                sortCodeMap.put(objectId, sortCode);
                sortCode ++;
            }

            Workbook workbook = new XSSFWorkbook();
            Sheet sheet = workbook.createSheet("数据");

            Font font = workbook.createFont();
            font.setFontName("宋体");
            font.setFontHeightInPoints((short)12);

            CellStyle contentCellStyle = workbook.createCellStyle();
            contentCellStyle.setFont(font);
            contentCellStyle.setWrapText(true);
            contentCellStyle.setBorderTop(BorderStyle.THIN);
            contentCellStyle.setBorderBottom(BorderStyle.THIN);
            contentCellStyle.setBorderLeft(BorderStyle.THIN);
            contentCellStyle.setBorderRight(BorderStyle.THIN);

            Row headerRow = sheet.createRow(0);
            String[] headers = {"序号", "被评人", "应打分人数", "实际打分人数", "题目", "得分", "标题", "得分", "综合得分"};
            for (int i = 0; i < headers.length; i++) {
                Cell cell = headerRow.createCell(i);
                cell.setCellValue(headers[i]);
                cell.setCellStyle(contentCellStyle);
            }
            // 填充数据并记录合并的行
            int rowCount = 1;
            Map<Long, Integer> classStartRows = new HashMap<>();
            Map<Long, Integer> classEndRows = new HashMap<>();

            Map<String, Integer> itemStartRows = new HashMap<>();
            Map<String, Integer> itemEndRows = new HashMap<>();

            for (ResultViewingPageVo el : list) {
                Row row = sheet.createRow(rowCount ++);
                Cell cell = row.createCell(0);
                cell.setCellValue(sortCodeMap.get(el.getObjectId()));
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(1);
                cell.setCellValue(el.getObjectIdCN());
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(2);
                cell.setCellValue(el.getPlanExecuterNum());
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(3);
                cell.setCellValue(el.getActualExecuterNum());
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(4);
                cell.setCellValue(el.getProblem());
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(5);
                cell.setCellValue(el.getSumScore());
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(6);
                cell.setCellValue(el.getTopic());
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(7);
                cell.setCellValue(el.getTopicScore());
                cell.setCellStyle(contentCellStyle);

                cell = row.createCell(8);
                cell.setCellValue(el.getSynthesisScore());
                cell.setCellStyle(contentCellStyle);

                Long objectId = el.getObjectId();
                if (!classStartRows.containsKey(objectId)) {
                    classStartRows.put(objectId, rowCount - 1);
                }
                classEndRows.put(objectId, rowCount - 1);

                String itemInfo = el.getObjectId() + el.getTopic();
                if (!itemStartRows.containsKey(itemInfo)) {
                    itemStartRows.put(itemInfo, rowCount - 1);
                }
                itemEndRows.put(itemInfo, rowCount - 1);
            }

            // 合并相同的人
            for (Map.Entry<Long, Integer> entry : classStartRows.entrySet()) {
                Long className = entry.getKey();
                int startRow = entry.getValue();
                int endRow = classEndRows.get(className);
                if (startRow != endRow) {
                    sheet.addMergedRegion(new CellRangeAddress(startRow, endRow, 0, 0));
                    sheet.addMergedRegion(new CellRangeAddress(startRow, endRow, 1, 1));
                    sheet.addMergedRegion(new CellRangeAddress(startRow, endRow, 2, 2));
                    sheet.addMergedRegion(new CellRangeAddress(startRow, endRow, 3, 3));
                    sheet.addMergedRegion(new CellRangeAddress(startRow, endRow, 8, 8));
                }
            }

            // 合并相同的题目
            for (Map.Entry<String, Integer> entry : itemStartRows.entrySet()) {
                String itemInfo = entry.getKey();
                int startRow = entry.getValue();
                int endRow = itemEndRows.get(itemInfo);
                if (startRow != endRow) {
                    sheet.addMergedRegion(new CellRangeAddress(startRow, endRow, 6, 6));
                    sheet.addMergedRegion(new CellRangeAddress(startRow, endRow, 7, 7));
                }
            }

            // 自动调整列宽
            for (int i = 0; i < headers.length; i++) {
                sheet.autoSizeColumn(i);
            }

            ByteArrayOutputStream bot = new ByteArrayOutputStream();
            workbook.write(bot);
            // 关闭工作簿
            workbook.close();

            return bot.toByteArray();
        }catch (Exception e){
            Log.error(e.getMessage(), e);
            throw new MyException("导出报错，请联系管理员");
        }
    }
}