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

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

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.module.evaluate.dto.EvaluateManagePageDto;
import com.xjrsoft.module.evaluate.dto.EvaluateManageScoreDto;
import com.xjrsoft.module.evaluate.dto.EvaluateWritePageDto;
import com.xjrsoft.module.evaluate.entity.*;
import com.xjrsoft.module.evaluate.mapper.*;
import com.xjrsoft.module.evaluate.service.IEvaluateManageService;
import com.xjrsoft.module.evaluate.vo.*;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
* @title: 评价管理
* @Author dzx
* @Date: 2024-01-16
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class EvaluateManageServiceImpl extends MPJBaseServiceImpl<EvaluateManageMapper, EvaluateManage> implements IEvaluateManageService {
    private final EvaluateManageMapper evaluateManageMapper;

    private final EvaluateObjectMapper evaluateObjectMapper;
    private final EvaluateExecuterMapper evaluateExecuterMapper;
    private final EvaluateItemMapper evaluateItemMapper;
    private final EvaluateManageItemMapper evaluateManageItemMapper;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(EvaluateManage evaluateManage) {
        evaluateManage.setStatus(-1);
        evaluateManageMapper.insert(evaluateManage);

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(EvaluateManage evaluateManage) {
        //TODO 修改分两种情况，一种是还没有发布的修改，一种是已经发布的修改，已发布的修改只能修改结束时间。
        evaluateManageMapper.updateById(evaluateManage);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        evaluateManageMapper.deleteBatchIds(ids);
        evaluateObjectMapper.delete(Wrappers.lambdaQuery(EvaluateObject.class).in(EvaluateObject::getEvaluateManageId, ids));
        evaluateExecuterMapper.delete(Wrappers.lambdaQuery(EvaluateExecuter.class).in(EvaluateExecuter::getEvaluateManageId, ids));
        return true;
    }

    @Override
    public Page<EvaluateManagePageVo> getPage(Page<EvaluateManagePageDto> page, EvaluateManagePageDto dto) {
        return evaluateManageMapper.getPage(page, dto);
    }

    @Override
    public Boolean release(Long id) {
        EvaluateManage evaluateManage = evaluateManageMapper.selectById(id);
        if(evaluateManage == null){
            throw new MyException("未查询到数据，请检查传入的id是否正确");
        }
//        evaluateManageItemMapper.cloneItems(evaluateManage.getEvaluateTemplateId(), evaluateManage.getId(), StpUtil.getLoginIdAsLong());

        //查询模板中的评价项
        List<EvaluateItem> evaluateItemList = evaluateItemMapper.selectList(
            new QueryWrapper<EvaluateItem>().lambda()
            .eq(EvaluateItem::getEvaluateTemplateId, evaluateManage.getEvaluateTemplateId())
        );
        //克隆一份，存到评价管理下面，可以采用sql语句
        for (EvaluateItem evaluateItem : evaluateItemList) {
            EvaluateManageItem manageItem = BeanUtil.toBean(evaluateItem, EvaluateManageItem.class);
            manageItem.setEvaluateManageId(evaluateManage.getId());
            manageItem.setEvaluateItemId(manageItem.getId());
            evaluateManageItemMapper.insert(manageItem);
        }
        //将评价管理状态改为进行中
        evaluateManage.setStatus(1);

        //设置两个定时器
        //第一个定时器控制结束

        //第二个定时器控制定时生成新的评价
        if(evaluateManage.getIsAutoCreate() != null && evaluateManage.getIsAutoCreate() == 1 && evaluateManage.getCreateFrequency() != null){

        }
        evaluateManageMapper.updateById(evaluateManage);
        return true;
    }

    @Override
    public Page<EvaluateWritePageVo> getMobilePage(Page<EvaluateWritePageDto> page, EvaluateWritePageDto dto) {
        Page<EvaluateWritePageVo> mobilePage = evaluateManageMapper.getMobilePage(page, dto);
        //获取所有评价管理下的所有的已评对象的得分
        Map<String, Map<String, Integer>> scoreByManageIdAndObject = new HashMap<>();
        if(dto != null && dto.getStatus() != null && dto.getStatus() == 1){
            List<Long> evaluateManageIdList = new ArrayList<>();
            List<Long> evaluateObjectIdList = new ArrayList<>();
            for (EvaluateWritePageVo record : mobilePage.getRecords()) {
                evaluateManageIdList.add(Long.parseLong(record.getEvaluateManageId()));
                evaluateObjectIdList.add(Long.parseLong(record.getEvaluateObjectId()));
            }

            if(evaluateManageIdList.size() > 0 && evaluateObjectIdList.size() > 0){
                List<EvaluateManageScoreVo> scoreList = evaluateManageMapper.getScoreList(new EvaluateManageScoreDto(){{
                    setEvaluateManageIdList(evaluateManageIdList);
                    setEvaluateObjectIdList(evaluateObjectIdList);
                    setUserId(StpUtil.getLoginIdAsLong());
                }});

                //将scoreList解析成map
                Map<String, List<EvaluateManageScoreVo>> scoreByManageId = scoreList.stream()
                        .collect(Collectors.groupingBy(EvaluateManageScoreVo::getEvaluateManageId));

                for (Map.Entry<String, List<EvaluateManageScoreVo>> entry : scoreByManageId.entrySet()) {
                    Map<String, Integer> scoreByObject = new HashMap<>();
                    for (EvaluateManageScoreVo evaluateManageScoreVo : entry.getValue()) {
                        scoreByObject.put(evaluateManageScoreVo.getEvaluateObjectId(), evaluateManageScoreVo.getScore());
                    }
                    scoreByManageIdAndObject.put(entry.getKey(), scoreByObject);
                }
            }
        }

        if(scoreByManageIdAndObject.size() > 0){
            for (EvaluateWritePageVo record : mobilePage.getRecords()) {
                record.setTotalScore(scoreByManageIdAndObject.get(record.getEvaluateManageId()).get(record.getEvaluateObjectId()));
            }
        }

        return mobilePage;
    }

    @Override
    public EvaluateWriteVo getWriteInfo(Long id) {
        return evaluateManageMapper.getWriteInfo(id);
    }

    @Override
    public List<EvaluateManageItemVo> getItemList(Long id) {
        return evaluateManageMapper.getItemList(id);
    }

    @Override
    public List<EvaluateManageItemVo> getResultList(Long id) {
        return evaluateManageMapper.getResultList(id, StpUtil.getLoginIdAsLong());
    }

}