双重预防项目-国泰新华二开定制版
SZH
2022-08-20 f9f0687195e0fe349185437d22c495d74c8d4a20
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
package com.ruoyi.project.tr.region.service;
 
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.framework.aspectj.lang.annotation.DataScope;
import com.ruoyi.framework.web.domain.Ztree;
import com.ruoyi.project.system.role.domain.Role;
import com.ruoyi.project.tr.region.domain.Region;
import com.ruoyi.project.tr.region.mapper.RegionMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * 区域/位置管理 服务实现
 * 
 * @author ruoyi
 */
@Service
public class RegionServiceImpl implements IRegionService
{
    @Autowired
    private RegionMapper regionMapper;
 
    /**
     * 查询区域/位置管理数据
     * 
     * @param region 区域/位置信息
     * @return 区域/位置信息集合
     */
    @Override
    @DataScope(deptAlias = "d")
    public List<Region> selectRegionList(Region region)
    {
        return regionMapper.selectRegionList(region);
    }
 
    @Override
    public List<Region> selectRegionListByCompanyId(Long companyId)
    {
        Region region = new Region();
        region.setCompanyId(companyId);
        return regionMapper.selectRegionList(region);
    }
 
    /**
     * 查询区域/位置管理树
     * 
     * @param region 区域/位置信息
     * @return 所有区域/位置信息
     */
    @Override
    @DataScope(deptAlias = "d")
    public List<Ztree> selectRegionTree(Region region)
    {
        List<Region> regionList = regionMapper.selectRegionList(region);
        List<Ztree> ztrees = initZtree(regionList);
        return ztrees;
    }
 
    /**
     * 根据角色ID查询区域/位置(数据权限)
     *
     * @param role 角色对象
     * @return 区域/位置列表(数据权限)
     */
    @Override
    public List<Ztree> roleRegionTreeData(Role role)
    {
        Long roleId = role.getRoleId();
        List<Ztree> ztrees = new ArrayList<Ztree>();
 
        Region region = new Region();
        region.setCompanyId(role.getCompanyId());
        List<Region> regionList = selectRegionList(region);
 
        if (StringUtils.isNotNull(roleId))
        {
            List<String> roleRegionList = regionMapper.selectRoleRegionTree(roleId,role.getCompanyId());
            ztrees = initZtree(regionList, roleRegionList);
        }
        else
        {
            ztrees = initZtree(regionList);
        }
        return ztrees;
    }
 
    /**
     * 对象转区域/位置树
     *
     * @param regionList 区域/位置列表
     * @return 树结构列表
     */
    public List<Ztree> initZtree(List<Region> regionList)
    {
        return initZtree(regionList, null);
    }
 
    /**
     * 对象转区域/位置树
     *
     * @param regionList 区域/位置列表
     * @param roleRegionList 角色已存在菜单列表
     * @return 树结构列表
     */
    public List<Ztree> initZtree(List<Region> regionList, List<String> roleRegionList)
    {
        List<Ztree> ztrees = new ArrayList<Ztree>();
        boolean isCheck = StringUtils.isNotNull(roleRegionList);
        for (Region region : regionList)
        {
            if (UserConstants.DEPT_NORMAL.equals(region.getStatus()))
            {
                Ztree ztree = new Ztree();
                ztree.setId(region.getRegionId());
                ztree.setpId(region.getParentId());
                ztree.setName(region.getRegionName());
                ztree.setTitle(region.getRegionName());
                if (isCheck)
                {
                    ztree.setChecked(roleRegionList.contains(region.getRegionId() + region.getRegionName()));
                }
                ztrees.add(ztree);
            }
        }
        return ztrees;
    }
 
    /**
     * 查询区域/位置人数
     * 
     * @param parentId 区域/位置ID
     * @return 结果
     */
    @Override
    public int selectRegionCount(Long parentId)
    {
        Region region = new Region();
        region.setParentId(parentId);
        return regionMapper.selectRegionCount(region);
    }
 
    /**
     * 查询区域/位置是否存在用户
     * 
     * @param regionId 区域/位置ID
     * @return 结果 true 存在 false 不存在
     */
    @Override
    public boolean checkRegionExistUser(Long regionId)
    {
        int result = regionMapper.checkRegionExistUser(regionId);
        return result > 0;
    }
 
    /**
     * 删除区域/位置管理信息
     * 
     * @param regionId 区域/位置ID
     * @return 结果
     */
    @Override
    public int deleteRegionById(Long regionId)
    {
        return regionMapper.deleteRegionById(regionId);
    }
 
    /**
     * 新增保存区域/位置信息
     * 
     * @param region 区域/位置信息
     * @return 结果
     */
    @Override
    public int insertRegion(Region region)
    {
        if (region.getParentId()!=0L){
            Region info = regionMapper.selectRegionById(region.getParentId());
 
            // 如果父节点不为"正常"状态,则不允许新增子节点
            if (!UserConstants.DEPT_NORMAL.equals(info.getStatus()))
            {
                throw new BusinessException("区域/位置停用,不允许新增");
            }else{
                region.setAncestors("0");
            }
            region.setAncestors(info.getAncestors() + "," + region.getParentId());
        }
 
        region.setCreateBy(ShiroUtils.getLoginName());
 
        return regionMapper.insertRegion(region);
    }
 
    /**
     * 修改保存区域/位置信息
     * 
     * @param region 区域/位置信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateRegion(Region region)
    {
        Region newParentRegion = regionMapper.selectRegionById(region.getParentId());
        Region oldRegion = selectRegionById(region.getRegionId());
        if (StringUtils.isNotNull(newParentRegion) && StringUtils.isNotNull(oldRegion))
        {
            String newAncestors = newParentRegion.getAncestors() + "," + newParentRegion.getRegionId();
            String oldAncestors = oldRegion.getAncestors();
            region.setAncestors(newAncestors);
            updateRegionChildren(region.getRegionId(), newAncestors, oldAncestors);
        }
        region.setUpdateBy(ShiroUtils.getLoginName());
        int result = regionMapper.updateRegion(region);
        if (UserConstants.DEPT_NORMAL.equals(region.getStatus()))
        {
            // 如果该区域/位置是启用状态,则启用该区域/位置的所有上级区域/位置
            updateParentRegionStatus(region);
        }
        return result;
    }
 
    /**
     * 修改该区域/位置的父级区域/位置状态
     * 
     * @param region 当前区域/位置
     */
    private void updateParentRegionStatus(Region region)
    {
        String updateBy = region.getUpdateBy();
        region = regionMapper.selectRegionById(region.getRegionId());
        region.setUpdateBy(updateBy);
        regionMapper.updateRegionStatus(region);
    }
 
    /**
     * 修改子元素关系
     * 
     * @param regionId 被修改的区域/位置ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateRegionChildren(Long regionId, String newAncestors, String oldAncestors)
    {
        List<Region> children = regionMapper.selectChildrenRegionById(regionId);
        for (Region child : children)
        {
            child.setAncestors(child.getAncestors().replace(oldAncestors, newAncestors));
        }
        if (children.size() > 0)
        {
            regionMapper.updateRegionChildren(children);
        }
    }
 
    /**
     * 修改子元素关系
     * 
     * @param regionId 区域/位置ID
     * @param ancestors 元素列表
     */
    public void updateRegionChildren(Long regionId, String ancestors)
    {
        Region region = new Region();
        region.setParentId(regionId);
        List<Region> childrens = regionMapper.selectRegionList(region);
        for (Region children : childrens)
        {
            children.setAncestors(ancestors + "," + region.getParentId());
        }
        if (childrens.size() > 0)
        {
            regionMapper.updateRegionChildren(childrens);
        }
    }
 
    /**
     * 根据区域/位置ID查询信息
     * 
     * @param regionId 区域/位置ID
     * @return 区域/位置信息
     */
    @Override
    public Region selectRegionById(Long regionId)
    {
        return regionMapper.selectRegionById(regionId);
    }
 
    /**
     * 校验区域/位置名称是否唯一
     * 
     * @param region 区域/位置信息
     * @return 结果
     */
    @Override
    public String checkRegionNameUnique(Region region)
    {
        Long regionId = StringUtils.isNull(region.getRegionId()) ? -1L : region.getRegionId();
        Region info = regionMapper.checkRegionNameUnique(region.getRegionName(), region.getParentId(),region.getCompanyId());
        if (StringUtils.isNotNull(info) && info.getRegionId().longValue() != regionId.longValue())
        {
            return UserConstants.DEPT_NAME_NOT_UNIQUE;
        }
        return UserConstants.DEPT_NAME_UNIQUE;
    }
}