执法评价相关添加

ZQN

2024-06-22 b2c1822dc9ae8a67872193d182d9335d9a99655c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package com.project.enforce.service.impl;
 
import cn.hutool.core.convert.Convert;
import com.project.common.exception.base.BaseException;
import com.project.common.utils.JsonUtils;
import com.project.common.utils.NumberUtils;
import com.project.common.utils.StringUtils;
import com.project.enforce.domain.EnforceEvaluateAnswer;
import com.project.enforce.domain.EnforceEvaluateLog;
import com.project.enforce.domain.EnforceEvaluateQuestion;
import com.project.enforce.domain.EnforceOrder;
import com.project.enforce.domain.bo.editBo.EnforceEvaluateBo;
import com.project.enforce.domain.vo.EnforceEvaluateVo;
import com.project.enforce.service.*;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.math.BigDecimal;
import java.util.List;
 
/**
 * 功能描述：
 *
 * @author ZQN
 * @version 1.0
 */
 
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class EnforceEvaluateServiceImpl implements IEnforceEvaluateService
{
 
    private final IEnforceEvaluateQuestionService questionService;
    private final IEnforceEvaluateAnswerService answerService;
    private final IEnforceOrderService orderService;
    private final IEnforceEvaluateLogService evaluateLogService;
 
 
    @Override//保存
    @Transactional
    public Boolean save(EnforceEvaluateBo bo)
    {
        questionService.clearQuestionAndAnswer();
        List<EnforceEvaluateQuestion> questionList = bo.getQuestionList();
        if (StringUtils.isEmpty(questionList)){
            throw new BaseException("评价项不可为空！");
        }
        for (EnforceEvaluateQuestion question : questionList) {
            if (question.getQuestionType()==1 && StringUtils.isEmpty(question.getAnswerList())){
                throw new BaseException("选择类型答案不可为空！");
            }
            if (question.getQuestionId()==null){
                int count = questionService.count(questionService.lq()
                        .eq(EnforceEvaluateQuestion::getQuestionName, question.getQuestionId()));
                if (count>0) {
                    throw new BaseException(StringUtils.format("{}，重复，请重试！", question.getQuestionName()));
                }
            } else {
                int count = questionService.count(questionService.lq().
                        eq(EnforceEvaluateQuestion::getQuestionName, question.getQuestionId())
                        .ne(EnforceEvaluateQuestion::getQuestionId,question.getQuestionId()));
                if (count>0) {
                    throw new BaseException(StringUtils.format("{}，题目重复，请重试！", question.getQuestionName()));
                }
            }
            questionService.saveOrUpdate(question);
            if (StringUtils.isNotEmpty(question.getAnswerList())){
                EnforceEvaluateQuestion one = questionService.getOne(questionService.lq().eq(EnforceEvaluateQuestion::getQuestionName, question.getQuestionName()));
                question.getAnswerList().forEach(enforceEvaluateAnswer -> {
                    enforceEvaluateAnswer.setQuestionId(one.getQuestionId());
                    enforceEvaluateAnswer.setQuestionName(one.getQuestionName());
                });
                answerService.saveOrUpdateBatch(question.getAnswerList());
            }
        }
        return true;
    }
 
    @Override//评价设置详情
    public EnforceEvaluateVo getInfo()
    {
        EnforceEvaluateVo vo = new EnforceEvaluateVo();
        List<EnforceEvaluateQuestion> questionList = questionService.list();
        for (EnforceEvaluateQuestion question : questionList) {
            if (question.getQuestionType()==1){
                List<EnforceEvaluateAnswer> answerList = answerService.list(answerService.lq().eq(EnforceEvaluateAnswer::getQuestionId, question.getQuestionId()));
                question.setAnswerList(answerList);
            }
        }
        vo.setQuestionList(questionList);
        return vo;
    }
 
    @Override
    @Transactional
    public Boolean saveOrder(EnforceEvaluateBo bo)
    {
        if (bo.getOrderId()==null){
            throw new BaseException("请选择评价执法单！");
        }
        List<EnforceEvaluateQuestion> questionList = bo.getQuestionList();
        if (StringUtils.isEmpty(questionList)){
            throw new BaseException("评价项不可为空！");
        }
        int count = evaluateLogService.count(EnforceEvaluateLog::getOrderId, bo.getOrderId());
        if (count>0) {
            throw new BaseException("该执法单已评价！");
        }
        BigDecimal totalScore = BigDecimal.ZERO;
        for (EnforceEvaluateQuestion question : questionList) {
            totalScore = NumberUtils.add(totalScore, question.getGetScore());
        }
        EnforceOrder order = orderService.getById(bo.getOrderId());
        EnforceEvaluateLog evaluateLog = Convert.convert(EnforceEvaluateLog.class, order);
        evaluateLog.setQuestionRemark(bo.getQuestionRemark());
        evaluateLog.setTotalScore(NumberUtils.divToBigDecSca2(totalScore,1));
        evaluateLog.setQuestionStatic(JsonUtils.objectToJson(bo.getQuestionList()));
 
        evaluateLogService.saveOrUpdate(evaluateLog);
        return orderService.update(orderService.lu()
                .set(EnforceOrder::getIsEva,1)
                .set(EnforceOrder::getTotalScore, totalScore)
        );
    }
 
 
}