众泰项目新迁

郑永安

2023-09-19 69185134fcfaf913ea45f1255677225a2cc311a4

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
150
151
152
package com.gk.hotwork.specialWork.service.baseService.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gk.hotwork.Domain.Enum.ResultCodes;
import com.gk.hotwork.Domain.Exception.BusinessException;
import com.gk.hotwork.specialWork.entity.ApprovalRuleStep;
import com.gk.hotwork.specialWork.enums.RuleStatusEnum;
import com.gk.hotwork.specialWork.enums.RuleStepStatusEnum;
import com.gk.hotwork.specialWork.model.query.db.ApprovalRuleStepListDbQuery;
import com.gk.hotwork.specialWork.repository.ApprovalRuleStepRepository;
import com.gk.hotwork.specialWork.service.baseService.ApprovalRuleStepService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.time.LocalDateTime;
import java.util.List;
 
@Service("ApprovalRuleStepService")
public class ApprovalRuleStepServiceImpl extends ServiceImpl<ApprovalRuleStepRepository, ApprovalRuleStep> implements ApprovalRuleStepService {
 
    @Autowired
    private ApprovalRuleStepRepository approvalRuleStepRepository;
 
 
    @Override
    public int saveOneStep(ApprovalRuleStep step) {
        step.setStatus(RuleStepStatusEnum.VALID.getCode());
        step.setGmtCreate(LocalDateTime.now());
        return baseMapper.insert(step);
    }
    /**
     * 更新
     */
    @Override
    public int updateOneStep(ApprovalRuleStep step) {
        step.setGmtModified(LocalDateTime.now());
        return baseMapper.updateById(step);
    }
 
    /**
     * 批量删除
     * @param stepIds 主键
     * @return
     */
    @Override
    public int updateStatusByStepIds(List<Long> stepIds) {
        return baseMapper.updateStatusByStepIds(stepIds,RuleStepStatusEnum.ABANDONED.getCode());
    }
 
    /**
     * 单挑删除
     * @param stepId
     * @return
     */
    @Override
    public int updateStatusByStepId(Long stepId) {
        return baseMapper.updateStatusByStepId(stepId,RuleStepStatusEnum.ABANDONED.getCode());
    }
 
    /**
     * 根据规则 ruleIds 删除层级数据
     * @param ruleIds 规则ids
     * @return
     */
    @Override
    public int updateStatusByRuleIds(List<Long> ruleIds) {
        return baseMapper.updateStatusByRuleIds(ruleIds,RuleStepStatusEnum.ABANDONED.getCode());
    }
 
    /**
     * 根据规则 ruleId 删除层级数据
     * @param ruleId 规则id
     * @return
     */
    @Override
    public int updateStatusByRuleId(Long ruleId) {
        return baseMapper.updateStatusByRuleId(ruleId,RuleStepStatusEnum.ABANDONED.getCode());
    }
 
    /**
     * 根据规则id获取集合
     * @param ruleId
     * @return
     */
    @Override
    public List<ApprovalRuleStep> listByRuleId(Long ruleId) {
        return baseMapper.listByRuleId(ruleId,RuleStepStatusEnum.VALID.getCode());
    }
    /**
     * 根据规则id获取层级集合id
     * @param ruleId
     * @return
     */
    @Override
    public List<Long> listStepIdByRuleId(Long ruleId) {
        return baseMapper.listStepIdByRuleId(ruleId,RuleStatusEnum.VALID.getCode());
    }
 
    @Override
    public List<ApprovalRuleStep> listStep(ApprovalRuleStepListDbQuery query){
        query.setStatus(RuleStatusEnum.VALID.getCode());
        return baseMapper.listByConditions(query);
    }
 
    @Override
    public List<ApprovalRuleStep> listStepByNoConditions() {
        return baseMapper.selectList(new LambdaQueryWrapper<ApprovalRuleStep>()
                .eq(ApprovalRuleStep::getStatus,RuleStepStatusEnum.VALID.getCode())
        );
    }
 
 
    @Override
    public List<ApprovalRuleStep> listApprovalRuleStepByRuleId(Long ruleId) {
        if (ruleId == null) {
            throw new BusinessException(ResultCodes.SERVER_PARAM_NULL);
        }
        return approvalRuleStepRepository.selectList(new LambdaQueryWrapper<ApprovalRuleStep>()
                // 规则id
                .eq(ApprovalRuleStep::getRuleId,ruleId)
                // 状态
                .eq(ApprovalRuleStep::getStatus,RuleStepStatusEnum.VALID.getCode())
        );
    }
 
    /**
     * 更新一条数据（将pre_step_id置空）
     */
    @Override
    public int updateStepAndEmptyPreStepId(ApprovalRuleStep step) {
        return baseMapper.updateStepAndEmptyPreStepId(step);
    }
 
    @Override
    public int saveStepList(List<ApprovalRuleStep> saveStepList) {
 
        return baseMapper.saveStepList( saveStepList);
    }
 
    /**
     * 批量更新
     * @param updateStepList
     * @return
     */
    @Override
    public int updateBatchStep(List<ApprovalRuleStep> updateStepList) {
        return baseMapper.updateBatchStep(updateStepList);
    }
 
 
}