fuliqi
2024-07-09 ce7964aba19721cebdd9eb7d475ac651a6dca6bf
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package com.ycl.platform.service.impl;
 
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycl.platform.domain.entity.CalculateRule;
import com.ycl.platform.domain.entity.TContract;
import com.ycl.platform.domain.vo.CalculateRuleCascaderVO;
import com.ycl.platform.mapper.CalculateRuleMapper;
import com.ycl.platform.mapper.TContractMapper;
import com.ycl.platform.service.ICalculateRuleService;
import com.ycl.system.domain.TreeUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import utils.DateUtils;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
/**
 * 违约规则Service业务层处理
 *
 * @author ruoyi
 * @date 2024-04-01
 */
@Service
public class CalculateRuleServiceImpl extends ServiceImpl<CalculateRuleMapper, CalculateRule> implements ICalculateRuleService {
    @Autowired
    private CalculateRuleMapper calculateRuleMapper;
    @Autowired
    private TContractMapper contractMapper;
 
    /**
     * 查询违约规则
     *
     * @param id 违约规则主键
     * @return 违约规则
     */
    @Override
    public CalculateRule selectDefaultRuleById(Long id) {
        return calculateRuleMapper.selectById(id);
    }
 
    /**
     * 查询违约规则列表
     *
     * @param calculateRule 违约规则
     * @return 违约规则
     */
    @Override
    public List<CalculateRule> selectDefaultRuleList(CalculateRule calculateRule) {
        return calculateRuleMapper.selectDefaultRuleList(calculateRule);
    }
 
    /**
     * 新增违约规则
     *
     * @param calculateRule 违约规则
     * @return 结果
     */
    @Override
    public int insertDefaultRule(CalculateRule calculateRule) {
        calculateRule.setCreateTime(DateUtils.getNowDate());
        return calculateRuleMapper.insertDefaultRule(calculateRule);
    }
 
    /**
     * 修改违约规则
     *
     * @param calculateRule 违约规则
     * @return 结果
     */
    @Override
    public int updateDefaultRule(CalculateRule calculateRule) {
        calculateRule.setUpdateTime(DateUtils.getNowDate());
        return calculateRuleMapper.updateDefaultRule(calculateRule);
    }
 
    /**
     * 批量删除违约规则
     *
     * @param ids 需要删除的违约规则主键
     * @return 结果
     */
    @Override
    public int deleteDefaultRuleByIds(Long[] ids) {
        return calculateRuleMapper.deleteDefaultRuleByIds(ids);
    }
 
    /**
     * 删除违约规则信息
     *
     * @param id 违约规则主键
     * @return 结果
     */
    @Override
    public int deleteDefaultRuleById(Long id) {
        return calculateRuleMapper.deleteDefaultRuleById(id);
    }
 
    /**
     * 获取合同Excel规则
     *
     * @param file 合同Excel文件
     * @return 规则
     */
 
    @Override
    public List<CalculateRule> readExcel(MultipartFile file) {
        List<CalculateRule> calculateRuleList = new ArrayList<>();
        try {
            EasyExcel.read(file.getInputStream(), CalculateRule.class, new ReadListener<CalculateRule>() {
                        @Override
                        public void invoke(CalculateRule calculateRule, AnalysisContext analysisContext) {
                            calculateRule.setId(null);
                            calculateRuleList.add(calculateRule);
                        }
 
                        @Override
                        public void doAfterAllAnalysed(AnalysisContext analysisContext) {
                        }
 
                    })
                    .head(CalculateRule.class)
                    .sheet()
                    .doRead();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return calculateRuleList;
    }
 
    @Override
    public List<CalculateRule> getRuleListByContractId(Integer contractId) {
        List<CalculateRule> list = new LambdaQueryChainWrapper<>(calculateRuleMapper)
                .eq(CalculateRule::getContractId, contractId)
                .list();
        return TreeUtils.build(list, 0L);
    }
 
    @Override
    public List<CalculateRuleCascaderVO> getRuleListByUnitId(Integer unitId) {
        return TreeUtils.build(calculateRuleMapper.getRuleListByUnitId(unitId, DateUtils.getDate()), 0L);
    }
}