用户导出,案件成员导出

baizonghao

2023-04-23 028bd9c7cccb1ba7569636c631fa3c83a16d3e48

 src/main/java/com/example/jz/service/impl/CauseServiceImpl.java

@@ -1,19 +1,413 @@
package com.example.jz.service.impl;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.jz.dao.CauseDao;
import com.example.jz.modle.entity.Cause;
import com.example.jz.dao.*;
import com.example.jz.enums.CauseEnums;
import com.example.jz.exception.BusinessException;
import com.example.jz.modle.PageParam;
import com.example.jz.modle.dto.*;
import com.example.jz.modle.entity.*;
import com.example.jz.modle.vo.CauseReportVo;
import com.example.jz.modle.vo.CauseVo;
import com.example.jz.modle.vo.NewCauseVo;
import com.example.jz.modle.vo.UserVo;
import com.example.jz.service.CauseService;
import com.example.jz.service.ReportService;
import com.example.jz.service.UserService;
import com.example.jz.utils.IdUtils;
import lombok.SneakyThrows;
import org.springframework.beans.BeanUtils;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * (Cause)表服务实现类
 * 案件表(Cause)表服务实现类
 *
 * @author makejava
 * @since 2022-07-11 16:55:41
 * @since 2022-07-13 11:52:58
 */
@Service("causeService")
public class CauseServiceImpl extends ServiceImpl<CauseDao, Cause> implements CauseService {

}
    @Resource
    CauseDao causeDao;
    @Resource
    UserDao userDao;
    @Resource
    ReportDao reportDao;
    @Resource
    CauseService causeService;
    @Resource
    GroupDao groupDao;
    @Resource
    GroupUserDao groupUserDao;
    @Resource
    UserService userService;
    @Resource
    ReportService reportService;
    @Resource
    MessageDao messageDao;
    @Resource
    AnnouncementDao announcementDao;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer addCause(CauseDto causeDto) {
        //��������
        Cause cause = new Cause();
        BeanUtils.copyProperties(causeDto, cause);
        cause.setCtime(new Date());
        causeService.save(cause);
        //创建群组
        Group group = new Group();
        group.setCtime(new Date());
        group.setGroupName(causeDto.getName());
        group.setUserId(causeDto.getUserId());
        group.setCauseId(cause.getId());
        return groupDao.insert(group);
    }

    @Override
    public PageParam<CauseVo> getCauserListByCondition(String cause, Integer status, Integer size, Integer current) {
        QueryWrapper<Cause> causeQueryWrapper = new QueryWrapper<>();
        if (StringUtils.isNotBlank(cause)) {
            causeQueryWrapper.and(a -> a.like(StringUtils.isNotBlank(cause), "number", cause)
                    .or(StringUtils.isNotBlank(cause))
                    .like(StringUtils.isNotBlank(cause), "name", cause));
        }
        if (status != null) {
            causeQueryWrapper.eq("status", status);
        }
        causeQueryWrapper.orderByDesc("ctime");
        PageParam<Cause> causePageParam = new PageParam<>();
        if (size != null) {
            causePageParam.setSize(size);
        }
        if (current != null) {
            causePageParam.setCurrent(current);
        }
        PageParam<Cause> causePage = causeDao.selectPage(causePageParam, causeQueryWrapper);
        List<CauseVo> causeVos = causePage.getRecords().stream().map(
                a -> {
                    CauseVo causeVo = new CauseVo();
                    BeanUtils.copyProperties(a, causeVo);
                    causeVo.setUserName(userDao.selectOne(new QueryWrapper<User>().eq("id", a.getUserId())).getRealName());
                    causeVo.setReportNumber(reportDao.selectCount(new QueryWrapper<Report>().eq("cause_id", a.getId())));
                    causeVo.setGroupId(groupDao.selectOne(new QueryWrapper<Group>().eq("cause_id", a.getId())).getId());
                    return causeVo;
                }).collect(Collectors.toList());
        PageParam<CauseVo> causeVoPageParam = new PageParam<>();
        BeanUtils.copyProperties(causePage, causeVoPageParam);
        causeVoPageParam.setRecords(causeVos);
        return causeVoPageParam;
    }

    @Override
    public PageParam<CauseVo> getCauserListByCondition(String cause, Integer status, Integer size, Integer current, Integer id) {
        QueryWrapper<Cause> causeQueryWrapper = new QueryWrapper<>();
        if (StringUtils.isNotBlank(cause)) {
            causeQueryWrapper.and(a -> a.like(StringUtils.isNotBlank(cause), "number", cause)
                    .or(StringUtils.isNotBlank(cause))
                    .like(StringUtils.isNotBlank(cause), "name", cause));
        }
        if (status != null) {
            causeQueryWrapper.eq("status", status);
        }
        causeQueryWrapper.eq("user_id", id);
        causeQueryWrapper.orderByDesc("ctime");
        PageParam<Cause> causePageParam = new PageParam<>();
        if (size != null) {
            causePageParam.setSize(size);
        }
        if (current != null) {
            causePageParam.setCurrent(current);
        }
        PageParam<Cause> causePage = causeDao.selectPage(causePageParam, causeQueryWrapper);
        List<CauseVo> causeVos = causePage.getRecords().stream().map(
                a -> {
                    CauseVo causeVo = new CauseVo();
                    BeanUtils.copyProperties(a, causeVo);
                    causeVo.setUserName(userDao.selectOne(new QueryWrapper<User>().eq("id", a.getUserId())).getRealName());
                    causeVo.setReportNumber(reportDao.selectCount(new QueryWrapper<Report>().eq("cause_id", a.getId())));
                    causeVo.setGroupId(groupDao.selectOne(new QueryWrapper<Group>().eq("cause_id", a.getId())).getId());
                    return causeVo;
                }).collect(Collectors.toList());
        PageParam<CauseVo> causeVoPageParam = new PageParam<>();
        BeanUtils.copyProperties(causePage, causeVoPageParam);
        causeVoPageParam.setRecords(causeVos);
        return causeVoPageParam;
    }

    @Override
    public List<NewCauseVo> getVxCauseList(String phone) {

        User user = userDao.selectOne(new LambdaQueryWrapper<User>().eq(User::getUserMobile, phone));

        List<Report> reports = reportDao.selectList(new LambdaQueryWrapper<Report>().eq(Report::getUserId, user.getId()));

        List<Integer> list = reports.stream()
                .map(item -> item.getCauseId())
                .filter(integer -> integer != null)
                .distinct()
                .collect(Collectors.toList());
        List<NewCauseVo> res;
        if (!Objects.isNull(list) && list.size()!= 0){
            List<Cause> causes = causeDao.selectList(new LambdaQueryWrapper<Cause>().notIn(Cause::getId, list));
            res = causes.stream()
                    .map(item -> {
                        NewCauseVo newCauseVo = new NewCauseVo();
                        newCauseVo.setName(item.getName());
                        newCauseVo.setId(item.getId());
                        return newCauseVo;
                    }).collect(Collectors.toList());
        }else {
            List<Cause> causes = causeDao.selectList(null);
            res = causes.stream()
                    .map(item -> {
                        NewCauseVo newCauseVo = new NewCauseVo();
                        newCauseVo.setName(item.getName());
                        newCauseVo.setId(item.getId());
                        return newCauseVo;
                    }).collect(Collectors.toList());
        }
        return res;
    }

    @Override
    public List<UserVo> getManagerList() {
        return userDao.selectList(new QueryWrapper<User>().eq("role", 1)).stream().map(a -> {
            UserVo userVo = new UserVo();
            userVo.setUserId(a.getId());
            userVo.setUserName(a.getRealName());
            return userVo;
        }).collect(Collectors.toList());
    }

    @Override
    public Integer updateCause(CauseDto causeDto, Integer id) {
        Cause cause = new Cause();
        BeanUtils.copyProperties(causeDto, cause);
        cause.setId(id);
        groupDao.update(null, Wrappers.lambdaUpdate(Group.class)
                .set(Group::getGroupName, causeDto.getName())
                        .set(Group::getUserId, causeDto.getUserId())
                .eq(Group::getCauseId, id));
        return causeDao.updateById(cause);
    }

    @Override
    public PageParam<CauseReportVo> getReporterList(Integer causeId) {
        PageParam<Report> PageParam = new PageParam<>();
        PageParam<Report> reportPageParam = reportDao.selectPage(PageParam, new QueryWrapper<Report>().eq("cause_id", causeId).orderByDesc("ctime"));
        PageParam<CauseReportVo> causeReportVoPageParam = new PageParam<>();
        BeanUtils.copyProperties(reportPageParam, causeReportVoPageParam);
        if (!reportPageParam.getRecords().isEmpty()) {
            List<CauseReportVo> causeReportVos = reportPageParam.getRecords().stream()
                    .map(
                            a -> {
                                CauseReportVo causeReportVo = new CauseReportVo();
                                User user = userDao.selectOne(new QueryWrapper<User>().eq("id", a.getUserId()));
                                BeanUtils.copyProperties(a, causeReportVo);
                                causeReportVo.setMobile(user.getUserMobile());
                                causeReportVo.setIdcard(user.getUserIdcard().replaceAll("(?<=[\\d]{3})\\d(?=[\\d]{4})", "*"));
                                causeReportVo.setReporterName(user.getRealName());
                                if (causeReportVo.getIsInGroup() == 1) {
                                    causeReportVo.setGroupId(groupDao.selectOne(new QueryWrapper<Group>().eq("cause_id", causeId)).getId());
                                }
                                return causeReportVo;
                            }
                    ).collect(Collectors.toList());
            causeReportVoPageParam.setRecords(causeReportVos);
        }
        return causeReportVoPageParam;
    }

    @Override
    public List<CauseReportExpDto> getExpList(Integer causeId) {
        List<Report> reports = reportDao.selectList(Wrappers.<Report>lambdaQuery().eq(Report::getCauseId, causeId));
        List<Integer> userIds = reports.stream().map(report -> report.getUserId()).collect(Collectors.toList());
        List<User> users = userDao.selectList(Wrappers.<User>lambdaQuery().in(User::getId, userIds));
        List<CauseReportExpDto> res = users.stream().map(new Function<User, CauseReportExpDto>() {
            @Override
            public CauseReportExpDto apply(User user) {
                CauseReportExpDto build = CauseReportExpDto.builder()
                        .realName(user.getRealName())
                        .userMobile(user.getUserMobile())
                        .userIdcard(user.getUserMobile())
                        .userIdcard(user.getUserIdcard())
                        .sex(user.getSex())
                        .location(user.getLocation())
                        .workingLocation(user.getWorkingLocation())
                        .ctime(user.getCtime())
                        .userMemo(user.getUserMemo())
                        .build();
                return build;
            }
        }).collect(Collectors.toList());
        return res;
    }

    @Override
    public List<Announcement> getGroupAnnouncement(Integer groupId) {
        return announcementDao.selectList(new QueryWrapper<Announcement>().eq("group_id", groupId));
    }

    @Override
    public void deleteCause(Integer id) {
        List<Report> reports = reportDao.selectList(new LambdaQueryWrapper<Report>().eq(Report::getCauseId, id));
        for (Report report : reports) {
            reportDao.deleteById(report.getId());
        }
        causeDao.deleteById(id);
        Group group = groupDao.selectOne(new LambdaQueryWrapper<Group>().eq(Group::getCauseId, id));
        if (group != null) {
            messageDao.delete(new LambdaQueryWrapper<Message>().eq(Message::getGroupId, group.getId()));
            groupUserDao.delete(new LambdaQueryWrapper<GroupUser>().eq(GroupUser::getGroupId, group.getId()));
        }
        groupDao.delete(new QueryWrapper<Group>().eq("cause_id", id));
    }

    @Override
    @SneakyThrows
    @Transactional(rollbackFor = BusinessException.class)
    public void loadFile(MultipartFile multipartFile) {
        ArrayList<CauseLoadDto> causeLoadDtos = new ArrayList<>();
        EasyExcel.read(multipartFile.getInputStream(), CauseLoadDto.class, new AnalysisEventListener<CauseLoadDto>() {
                    @Override
                    public void invoke(CauseLoadDto data, AnalysisContext context) {
                        if (StringUtils.isNotBlank(data.getName()) && StringUtils.isNotBlank(data.getUserName())) {
                            causeLoadDtos.add(data);
                        }
                    }

                    @Override
                    public void doAfterAllAnalysed(AnalysisContext analysisContext) {

                    }
                })
                .autoCloseStream(true)
                .doReadAll();
        causeLoadDtos.forEach(
                a -> {
                    Cause cause = new Cause();
                    BeanUtils.copyProperties(a, cause);
                    cause.setNumber(IdUtils.getAduitId());
                    if (StringUtils.isBlank(a.getStatus())) {
                        throw new BusinessException("状态不能为空");
                    }
                    if (a.getStatus().equals(CauseEnums.UNCHECKED.getMsg())) {
                        cause.setStatus(CauseEnums.UNCHECKED.value());
                    }
                    if (a.getStatus().equals(CauseEnums.NOTTOPUTONRECORD.getMsg())) {
                        cause.setStatus(CauseEnums.NOTTOPUTONRECORD.value());
                    }
                    if (a.getStatus().equals(CauseEnums.UNDERCONSIDERATION.getMsg())) {
                        cause.setStatus(CauseEnums.UNDERCONSIDERATION.value());
                    }
                    if (a.getStatus().equals(CauseEnums.CASECLOSED.getMsg())) {
                        cause.setStatus(CauseEnums.CASECLOSED.value());
                    }
                    if (a.getStatus().equals(CauseEnums.HASBEENDROPPED.getMsg())) {
                        cause.setStatus(CauseEnums.HASBEENDROPPED.value());
                    }
                    cause.setCtime(new Date());
                    if (StringUtils.isBlank(a.getUserName())) {
                        throw new BusinessException("负责人不允许为空");
                    }
                    if (userDao.selectOne(new QueryWrapper<User>().eq("real_name", a.getUserName())) == null) {
                        throw new BusinessException("负责人不存在");
                    }
                    Integer id = userDao.selectOne(new QueryWrapper<User>().eq("real_name", a.getUserName())).getId();
                    cause.setUserId(id);
                    causeService.save(cause);
                    Group group = new Group();
                    group.setCtime(new Date());
                    group.setUserId(id);
                    group.setGroupName(a.getName());
                    group.setCauseId(cause.getId());
                    groupDao.insert(group);
                });
    }

    @Override
    @Transactional
    public Boolean addReportPeople(AddReportDto addReportDto) {
        User user = userDao.selectOne(new LambdaQueryWrapper<User>(User.class).eq(User::getUserIdcard, addReportDto.getIdcard()));
        if (user == null) {
            // 如果用户不存在 则添加用户
            user = new User().setUserIdcard(addReportDto.getIdcard()).setUserMobile(addReportDto.getMobile()).setRealName(addReportDto.getReporterName())
                    .setModifyTime(new Date()).setUserRegtime(new Date()).setPic(addReportDto.getPic());
            userService.save(user);
        }
        Group group = groupDao.selectOne(new QueryWrapper<Group>().eq("cause_id", addReportDto.getCauseId()));
        // 添加人员进群组
        // groupUserDao.insert(new GroupUser().setGroupId(group.getId()).setUserId(user.getId()).setCtime(new Date()).setBanSpeech(0));
        // 添加报案信息
        Report report = new Report();
        BeanUtils.copyProperties(addReportDto, report);
        report
                .setIsInGroup(1)
                .setCreator(userDao.selectOne(new QueryWrapper<User>().eq("login_username", SecurityContextHolder.getContext().getAuthentication().getPrincipal())).getId())
                .setUserId(user.getId())
                .setCtime(new Date())
                .setStatus(1)
                .setReportMethod("现场报案")
                .setIsCommission("0")
                .setReportTime(new Date())
                .setCauseId(addReportDto.getCauseId());
        reportService.save(report);
        return groupUserDao.insert(new GroupUser().setGroupId(group.getId()).setUserId(report.getId()).setCtime(new Date()).setBanSpeech(0)) > 0;
    }

    @Override
    public List<Map<String, String>> getCauseIdAndName() {
        ArrayList<Map<String, String>> maps = new ArrayList<>();
        causeDao.selectList(new QueryWrapper<Cause>().eq("status", 0).or().eq("status", 2)).stream().forEach(a -> {
            Map<String, String> map = new HashMap<>();
            map.put("id", a.getId().toString());
            map.put("name", a.getName());
            maps.add(map);
        });
        return maps;
    }

    @Override
    @SneakyThrows
    public void loadFileReport(MultipartFile multipartFile, Integer causeId) {
        EasyExcel.read(multipartFile.getInputStream(), AddReportLoadDto.class, new AnalysisEventListener<AddReportLoadDto>() {
                    @Override
                    public void invoke(AddReportLoadDto data, AnalysisContext context) {
                        if (StringUtils.isNotBlank(data.getReporterName()) && StringUtils.isNotBlank(data.getIdcard())) {
                            AddReportDto addReportDto = new AddReportDto();
                            BeanUtils.copyProperties(data, addReportDto);
                            addReportDto.setCauseId(causeId);
                            addReportPeople(addReportDto);
                        }

                    }

                    @Override
                    public void doAfterAllAnalysed(AnalysisContext context) {

                    }
                })
                .autoCloseStream(true)
                .doReadAll();
    }
}