mitao
2025-02-21 31573d6180d15ef65ed0df9c2732495f40b12663
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
package com.panzhihua.service_community.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Lists;
import com.panzhihua.common.constants.Constants;
import com.panzhihua.common.model.dtos.community.cluster.PageClusterMemberDto;
import com.panzhihua.common.model.dtos.community.cluster.admin.AddClusterMemberAdminDto;
import com.panzhihua.common.model.dtos.community.cluster.admin.EditClusterMemberAdminDto;
import com.panzhihua.common.model.dtos.community.cluster.admin.PageClusterMemberAdminDto;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.cluster.admin.ClusterMemberNationVo;
import com.panzhihua.common.model.vos.community.cluster.admin.ComClusterMemberExcelErrorVO;
import com.panzhihua.common.model.vos.community.cluster.admin.ComClusterMemberExcelVO;
import com.panzhihua.common.model.vos.community.cluster.admin.PageClusterMemberAdminVo;
import com.panzhihua.service_community.dao.ComClusterOrganizationMapper;
import com.panzhihua.service_community.dao.ComClusterOrganizationMemberMapper;
import com.panzhihua.service_community.model.dos.ComClusterOrganizationDO;
import com.panzhihua.service_community.model.dos.ComClusterOrganizationMemberDO;
import com.panzhihua.service_community.service.ComClusterOrganizationMemberService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
 
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
 
/**
 * @author lyq
 * @date  2021-09-23 16:44:00
 * describe 群团组织成员表服务实现类
 */
@Slf4j
@Service
public class ComClusterOrganizationMemberServiceImpl extends ServiceImpl<ComClusterOrganizationMemberMapper, ComClusterOrganizationMemberDO> implements ComClusterOrganizationMemberService {
 
    @Resource
    private ComClusterOrganizationMapper comClusterOrganizationMapper;
 
    /**
     * 群团组织成员列表-小程序分页查询
     * @param pageClusterMemberDto  请求参数
     * @return  群团组织成员列表
     */
    @Override
    public R pageClusterMemberApplets(PageClusterMemberDto pageClusterMemberDto){
        return R.ok(this.baseMapper.pageClusterMemberApplets(new Page(pageClusterMemberDto.getPageNum(),pageClusterMemberDto.getPageSize()),pageClusterMemberDto));
    }
 
    /**
     * 分页查询群团组织成员列表
     * @param pageClusterMemberAdminDto 请求参数
     * @return  群团组织成员列表
     */
    @Override
    public R pageClusterMemberAdmin(PageClusterMemberAdminDto pageClusterMemberAdminDto){
        return R.ok(this.baseMapper.pageClusterMemberAdmin(new Page(pageClusterMemberAdminDto.getPageNum(),pageClusterMemberAdminDto.getPageSize()),pageClusterMemberAdminDto));
    }
 
    /**
     * 新增群团组织成员
     * @param addClusterMemberAdminDto  请求参数
     * @return  新增结果
     */
    @Override
    public R addClusterMemberAdmin(AddClusterMemberAdminDto addClusterMemberAdminDto){
 
        ComClusterOrganizationMemberDO organizationMemberDO = this.baseMapper.selectOne(new QueryWrapper<ComClusterOrganizationMemberDO>()
                .lambda().eq(ComClusterOrganizationMemberDO::getIdCard,addClusterMemberAdminDto.getIdCard())
                .eq(ComClusterOrganizationMemberDO::getIsDel,ComClusterOrganizationMemberDO.isOk.no)
                .eq(ComClusterOrganizationMemberDO::getCommunityId,addClusterMemberAdminDto.getCommunityId()));
        if(organizationMemberDO != null){
            return R.fail("该身份证号已存在,不可重复添加");
        }
        organizationMemberDO = new ComClusterOrganizationMemberDO();
        BeanUtils.copyProperties(addClusterMemberAdminDto,organizationMemberDO);
        organizationMemberDO.setCreateAt(new Date());
        if(this.baseMapper.insert(organizationMemberDO) > 0){
            return R.ok("添加成功");
        }
        return R.fail("添加失败");
    }
 
    /**
     * 编辑群团组织成员
     * @param editClusterMemberAdminDto 请求参数
     * @return  编辑结果
     */
    @Override
    public R editClusterMemberAdmin(EditClusterMemberAdminDto editClusterMemberAdminDto){
        ComClusterOrganizationMemberDO organizationMemberDO = this.baseMapper.selectById(editClusterMemberAdminDto.getId());
        if(organizationMemberDO == null){
            return R.fail("该组织成员不存在");
        }
 
        Integer count = this.baseMapper.selectCount(new QueryWrapper<ComClusterOrganizationMemberDO>().lambda()
                .eq(ComClusterOrganizationMemberDO::getCommunityId,editClusterMemberAdminDto.getCommunityId())
                .eq(ComClusterOrganizationMemberDO::getIdCard,editClusterMemberAdminDto.getIdCard())
                .eq(ComClusterOrganizationMemberDO::getIsDel,ComClusterOrganizationMemberDO.isOk.no)
                .ne(ComClusterOrganizationMemberDO::getId,editClusterMemberAdminDto.getId()));
        if(count > 0){
            return R.fail("该身份证号已存在,不可重复添加");
        }
        BeanUtils.copyProperties(editClusterMemberAdminDto,organizationMemberDO);
        organizationMemberDO.setUpdateAt(new Date());
        if(this.baseMapper.updateById(organizationMemberDO) > 0){
            return R.ok("编辑成功");
        }
        return R.fail("编辑失败");
    }
 
    /**
     * 删除群团组织成员
     * @param id    组织成员id
     * @return  删除结果
     */
    @Override
    public R deleteClusterMemberAdmin(Long id){
        ComClusterOrganizationMemberDO organizationMemberDO = new ComClusterOrganizationMemberDO();
        organizationMemberDO.setId(id);
        organizationMemberDO.setIsDel(ComClusterOrganizationMemberDO.isOk.yes);
        organizationMemberDO.setUpdateAt(new Date());
        if(this.baseMapper.updateById(organizationMemberDO) > 0){
            return R.ok("删除成功");
        }
        return R.fail("删除失败");
    }
 
    /**
     * 群团组织成员详情
     * @param id    组织成员id
     * @return  群团组织成员详情
     */
    @Override
    public R detailClusterMemberAdmin(Long id){
        ComClusterOrganizationMemberDO organizationMemberDO = this.baseMapper.selectById(id);
        if(organizationMemberDO == null){
            return R.fail("该组织成员不存在");
        }
        PageClusterMemberAdminVo memberAdminVo = new PageClusterMemberAdminVo();
        BeanUtils.copyProperties(organizationMemberDO,memberAdminVo);
        return R.ok(memberAdminVo);
    }
 
    /**
     * 查询系统民族列表
     * @return  民族列表
     */
    @Override
    public R memberNationListAdmin(){
        return R.ok(this.baseMapper.memberNationListAdmin(Constants.NATION_DICT_KEY));
    }
 
    /**
     * 群团组织成员导入
     * @param memberExcelList  导入数据
     * @param communityId   社区id
     * @param userId    操作用户id
     * @return  导入结果
     */
    @Override
    public R importClusterMember(List<ComClusterMemberExcelVO> memberExcelList, Long communityId, Long userId){
 
        //需要新增的数据
        List<ComClusterOrganizationMemberDO> saveList = Lists.newArrayList();
        //错误数据
        ArrayList<ComClusterMemberExcelErrorVO> mistakes = Lists.newArrayList();
        //查询当前社区现有的所有群团组织成员列表
        List<ComClusterOrganizationMemberDO> memberList = this.baseMapper.selectList(new QueryWrapper<ComClusterOrganizationMemberDO>().lambda()
                .eq(ComClusterOrganizationMemberDO::getCommunityId,communityId)
                .eq(ComClusterOrganizationMemberDO::getIsDel,ComClusterOrganizationMemberDO.isOk.no));
        HashMap<String, Object> memberMap = new HashMap<>();
        memberList.forEach(member -> {
            String key = member.getIdCard();
            memberMap.put(key, member);
        });
 
        //查询该社区现有的所有群团组织
        List<ComClusterOrganizationDO> clusterList = comClusterOrganizationMapper.selectList(new QueryWrapper<ComClusterOrganizationDO>().lambda()
                .eq(ComClusterOrganizationDO::getCommunityId,communityId).eq(ComClusterOrganizationDO::getIsDel,ComClusterOrganizationDO.isOk.no));
        HashMap<String, Object> clusterMap = new HashMap<>();
        clusterList.forEach(cluster -> {
            String key = cluster.getName();
            clusterMap.put(key, cluster);
        });
 
        List<ClusterMemberNationVo> nationList = this.baseMapper.memberNationListAdmin(Constants.NATION_DICT_KEY);
        HashMap<String, Object> nationMap = new HashMap<>();
        nationList.forEach(nation -> {
            String key = nation.getNationName();
            nationMap.put(key, nation.getNationCode());
        });
        Date nowDate = new Date();
        for (ComClusterMemberExcelVO memberExcel : memberExcelList) {
            Long clusterId = 0L;
 
            String nationCode = "";
 
            //判断成员是否已存在
            if(!isOnly(memberExcel.getIdCard(),memberMap)){
                ComClusterMemberExcelErrorVO memberExcelErrorVO = new ComClusterMemberExcelErrorVO();
                BeanUtils.copyProperties(memberExcel,memberExcelErrorVO);
                //判断该成员是否是已存在还是身份证号码重复
                ComClusterOrganizationMemberDO memberDO = (ComClusterOrganizationMemberDO)memberMap.get(memberExcel.getIdCard());
                if(memberDO.getName().equals(memberExcel.getName())){
                    memberExcelErrorVO.setError("该成员已存在");
                }else{
                    memberExcelErrorVO.setError("身份证号重复");
                }
                mistakes.add(memberExcelErrorVO);
                continue;
            }
 
            //判断组织是否存在
            if(isOnly(memberExcel.getClusterName(),clusterMap)){
                ComClusterMemberExcelErrorVO memberExcelErrorVO = new ComClusterMemberExcelErrorVO();
                BeanUtils.copyProperties(memberExcel,memberExcelErrorVO);
                memberExcelErrorVO.setError("该组织在本社区不存在");
                mistakes.add(memberExcelErrorVO);
                continue;
            }else{
                ComClusterOrganizationDO clusterDO = (ComClusterOrganizationDO)clusterMap.get(memberExcel.getClusterName());
                clusterId = clusterDO.getId();
            }
 
            //判断民族是否存在
            if(isOnly(memberExcel.getNation(),nationMap)){
                ComClusterMemberExcelErrorVO memberExcelErrorVO = new ComClusterMemberExcelErrorVO();
                BeanUtils.copyProperties(memberExcel,memberExcelErrorVO);
                memberExcelErrorVO.setError("您填写的民族不存在");
                mistakes.add(memberExcelErrorVO);
                continue;
            }else{
                nationCode = nationMap.get(memberExcel.getNation()).toString();
            }
 
            ComClusterOrganizationMemberDO clusterMember = new ComClusterOrganizationMemberDO();
            BeanUtils.copyProperties(memberExcel,clusterMember);
            clusterMember.setClusterId(clusterId);
            clusterMember.setNationCode(nationCode);
            clusterMember.setImageUrl(Constants.CLUSTER_MEMBER_DEFAULT_IMAGE_URL);
            clusterMember.setCreateAt(nowDate);
            clusterMember.setCommunityId(communityId);
            saveList.add(clusterMember);
            memberMap.put(clusterMember.getIdCard(),clusterMember);
        }
        //执行导入
        if(saveList.size() > 0){
           this.saveBatch(saveList);
        }
        //有错误,返回错误数据
        if(mistakes.size() > 0){
            return R.fail(mistakes);
        }
        return R.ok();
    }
 
    /**
     * 判重方法
     *
     * @param key
     *            主键
     * @param hashMap
     *            数据集
     * @return 存在即为false 不存在则为true
     */
    private boolean isOnly(String key, HashMap<String, Object> hashMap) {
        return ObjectUtils.isEmpty(hashMap.get(key));
    }
 
    /**
     * 群团组织导出数据查询
     * @param pageClusterMemberAdminDto 请求参数
     * @return  导出数据结果集
     */
    @Override
    public R exportClusterMember(PageClusterMemberAdminDto pageClusterMemberAdminDto){
        return R.ok(this.baseMapper.exportClusterMember(pageClusterMemberAdminDto));
    }
}