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
package org.springblade.system.service.impl;
 
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springblade.common.constant.CommonConstant;
import org.springblade.core.cache.utils.CacheUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.utils.Func;
import org.springblade.system.entity.Strategy;
import org.springblade.system.mapper.StrategyMapper;
import org.springblade.system.service.IStrategyService;
import org.springframework.data.domain.PageImpl;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
 
import static org.springblade.core.cache.constant.CacheConstant.SYS_CACHE;
 
/**
 * 密码策略(Strategy)表服务实现类
 *
 * @author makejava
 * @since 2023-03-20 15:25:05
 */
@Service
public class StrategyServiceImpl extends ServiceImpl<StrategyMapper, Strategy> implements IStrategyService {
 
    @Resource
    private StrategyMapper strategyMapper;
 
    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public Strategy queryById(String id) {
        return this.getById(id);
    }
 
    /**
     * 分页查询
     *
     * @param query 分页对象
     * @return 查询结果
     */
    @Override
    public PageImpl<Strategy> queryAllByPage(Query query) {
        Page<Strategy> strategyPage = new Page<>(query.getCurrent(), query.getSize());
        return new PageImpl<>(this.strategyMapper.queryAllByPage(strategyPage));
    }
 
    /**
     * 新增数据或者修改数据
     *
     * @param strategy 实例对象
     * @return 实例对象
     */
    @Override
    public boolean submit(Strategy strategy) {
        //判断是否携带id
        if(Func.isEmpty(strategy.getId())){
            //执行新增
            Strategy dbstrategy = this.getOne(Wrappers.<Strategy>query().lambda()
                .eq(Strategy::getStrategyName, strategy.getStrategyName()));
            //如果数据库中存在这条组合名称的记录直接返回
            if(!Func.isEmpty(dbstrategy)){
                throw new ServiceException("该密码策略已存在!");
            }
            //如果当前新增设置为默认密码策略，需要将已存在默认密码策略修改为非默认
            if(strategy.getIsDefault().equals("1") || strategy.getIsDefault() == 1){
                this.update(Wrappers.<Strategy>update().lambda()
                    .set(Strategy::getIsDefault, CommonConstant.NOT_SEALED_ID)
                    .eq(Strategy::getIsDefault, CommonConstant.DATA_SCOPE_CATEGORY));
            }
            if(Func.isEmpty(strategy.getCreateTime())){
                strategy.setCreateTime(new Date());
            }
            if(Func.isEmpty(strategy.getUpdateTime())){
                strategy.setUpdateTime(new Date());
            }
            boolean temp = super.saveOrUpdate(strategy);
            return temp;
        }else {
            //如果当前修改设置为默认密码策略，需要将已存在默认密码策略修改为非默认
            if(strategy.getIsDefault().equals("1") || strategy.getIsDefault() == 1){
                this.update(Wrappers.<Strategy>update().lambda()
                    .set(Strategy::getIsDefault,CommonConstant.NOT_SEALED_ID)
                    .eq(Strategy::getIsDefault,CommonConstant.DATA_SCOPE_CATEGORY));
            }else {
                if(Func.isEmpty(queryByIsDefault())){
                    throw new ServiceException("默认密码策略必须有且仅有一条!");
                }
            }
            if(Func.isEmpty(strategy.getUpdateTime())){
                strategy.setUpdateTime(new Date());
            }
            CacheUtil.clear(SYS_CACHE, Boolean.FALSE);
            return super.saveOrUpdate(strategy);
        }
    }
 
    /**
     * 通过主键删除数据
     *
     * @param ids 主键
     * @return 是否成功
     */
    @Override
    public boolean deleteByIds(List<String> ids) {
        Strategy strategy = this.getOne(Wrappers.<Strategy>query().lambda()
            .in(Strategy::getId,ids)
            .eq(Strategy::getIsDefault, CommonConstant.DATA_SCOPE_CATEGORY));
        //如果存在默认策略的id，就不能直接删除给出提示
        if(!Func.isEmpty(strategy)){
            throw new ServiceException("不能删除默认密码策略!");
        }
        boolean tenantTemp = this.removeBatchByIds(ids);
        return tenantTemp;
    }
 
    /**
     * 查询默认密码策略
     * @return
     */
    @Override
    public Long queryByIsDefault() {
        return this.getOne(Wrappers.<Strategy>query().lambda()
            .eq(Strategy::getIsDefault, CommonConstant.DATA_SCOPE_CATEGORY)).getId();
    }
 
}