Merge branch 'master' into 'test'

罗yu 元桥

2021-04-28 b6082fe75b377ac9c177736d98f36ae46e7cdb70

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/impl/ComActWorkGuideServiceImpl.java

New file
@@ -0,0 +1,141 @@
package com.panzhihua.service_community.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.model.dtos.community.PageActWorkGuideDTO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.ComActWorkGuideMaterialVO;
import com.panzhihua.common.model.vos.community.ComActWorkGuideVO;
import com.panzhihua.common.utlis.DifferentLongListUtil;
import com.panzhihua.service_community.dao.ComActWorkGuideDAO;
import com.panzhihua.service_community.dao.ComActWorkGuideMaterialDAO;
import com.panzhihua.service_community.model.dos.ComActWorkGuideDO;
import com.panzhihua.service_community.model.dos.ComActWorkGuideMaterialDO;
import com.panzhihua.service_community.service.ComActWorkGuideService;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @auther llming
 * @describe 办事指南
 */
@Service
public class ComActWorkGuideServiceImpl extends ServiceImpl<ComActWorkGuideDAO, ComActWorkGuideDO> implements ComActWorkGuideService {
    @Resource
    ComActWorkGuideMaterialDAO workGuideMaterialDAO;

    @Override
    public R addWorkGuide(ComActWorkGuideVO workGuideVO, Long userId) {
        ComActWorkGuideDO comActWorkGuideDO = new ComActWorkGuideDO();
        BeanUtils.copyProperties(workGuideVO, comActWorkGuideDO);
        comActWorkGuideDO.setCreateBy(userId);
        this.baseMapper.insert(comActWorkGuideDO);
        //保存办事指南材料
        workGuideVO.getMaterials().forEach(material -> {
            ComActWorkGuideMaterialDO workGuideMaterialDO = new ComActWorkGuideMaterialDO();
            workGuideMaterialDO.setMaterialName(material.getMaterialName());
            workGuideMaterialDO.setWorkGuideId(comActWorkGuideDO.getId());
            workGuideMaterialDAO.insert(workGuideMaterialDO);
        });
        return R.ok();
    }

    @Override
    public R editWorkGuide(ComActWorkGuideVO workGuideVO, Long userId) {
        if (workGuideVO.getId() == 0L) {
            return R.fail("Id有误！");
        }
        ComActWorkGuideDO workGuideDO = this.baseMapper.selectById(workGuideVO.getId());
        if (workGuideDO == null) {
            return R.fail("Id有误！");
        }
        BeanUtils.copyProperties(workGuideVO, workGuideDO);
        workGuideDO.setUpdateBy(userId);
        this.baseMapper.updateById(workGuideDO);
        if (workGuideVO.getMaterials().size() == 0) {//若编辑材料为null,执行删除操作
            workGuideMaterialDAO.delete(new LambdaQueryWrapper<ComActWorkGuideMaterialDO>()
                    .eq(ComActWorkGuideMaterialDO::getWorkGuideId, workGuideVO.getId()));
        } else {//若材料不为空，但是少了数据条数，也要执行删除
            List<ComActWorkGuideMaterialDO> workGuideMaterialDOS = workGuideMaterialDAO.selectList(new LambdaQueryWrapper<ComActWorkGuideMaterialDO>()
                    .eq(ComActWorkGuideMaterialDO::getWorkGuideId, workGuideVO.getId()));
            //1、筛选vo里面和db里，需要删除的材料数据
            List<Long> voMaterialIds = workGuideVO.getMaterials().stream()
                    .filter(materialVo -> materialVo.getId() != null)
                    .map(ComActWorkGuideMaterialVO::getId)
                    .collect(Collectors.toList());
            List<Long> deleteMaterialIds = workGuideMaterialDOS.stream()
                    .filter(workGuideMaterialDO -> !voMaterialIds.contains(workGuideMaterialDO.getId()))
                    .map(ComActWorkGuideMaterialDO::getId)
                    .collect(Collectors.toList());
            if (deleteMaterialIds.size() != 0) {
                workGuideMaterialDAO.deleteBatchIds(deleteMaterialIds);
            }
            workGuideVO.getMaterials().forEach(materialsVO -> {
                if (materialsVO.getId() != null && materialsVO.getId() != 0L) {
                    ComActWorkGuideMaterialDO workGuideMaterialDO1 = workGuideMaterialDOS.stream().filter(workGuideMaterialDO -> workGuideMaterialDO.getId()
                            .equals(materialsVO.getId())).findFirst().orElse(null);
                    if (workGuideMaterialDO1 != null) {//2、如果db有,执行编辑
                        workGuideMaterialDO1.setMaterialName(materialsVO.getMaterialName());
                        workGuideMaterialDAO.updateById(workGuideMaterialDO1);
                    }
                } else {//3、如果db没有，执行新增
                    ComActWorkGuideMaterialDO newWorkGuideMaterialDO = new ComActWorkGuideMaterialDO();
                    newWorkGuideMaterialDO.setMaterialName(materialsVO.getMaterialName());
                    newWorkGuideMaterialDO.setWorkGuideId(workGuideDO.getId());
                    workGuideMaterialDAO.insert(newWorkGuideMaterialDO);
                }
            });
        }
        return R.ok();
    }

    @Override
    public R detailWorkGuide(Long workGuideId) {
        ComActWorkGuideDO workGuideDO = this.baseMapper.selectById(workGuideId);
        if (workGuideDO == null) {
            return R.fail("Id有误！");
        }
        ComActWorkGuideVO vo = new ComActWorkGuideVO();
        BeanUtils.copyProperties(workGuideDO, vo);
        List<ComActWorkGuideMaterialDO> workGuideMaterialDOS = workGuideMaterialDAO.selectList(new LambdaQueryWrapper<ComActWorkGuideMaterialDO>()
                .eq(ComActWorkGuideMaterialDO::getWorkGuideId, workGuideId));
        workGuideMaterialDOS.forEach(workGuideMaterialDO -> {
            ComActWorkGuideMaterialVO workGuideMaterialVO = new ComActWorkGuideMaterialVO();
            workGuideMaterialVO.setId(workGuideMaterialDO.getId());
            workGuideMaterialVO.setMaterialName(workGuideMaterialDO.getMaterialName());
            vo.getMaterials().add(workGuideMaterialVO);
        });
        return R.ok(vo);
    }

    @Override
    public R pageWorkGuide(PageActWorkGuideDTO pageActWorkGuideDTO) {
        Page page = new Page<>();
        Long pageNum = pageActWorkGuideDTO.getPageNum();
        Long pageSize = pageActWorkGuideDTO.getPageSize();
        if (null == pageNum || 0 == pageNum) {
            pageNum = 1l;
        }
        if (null == pageSize || 0 == pageSize) {
            pageSize = 10l;
        }
        page.setSize(pageSize);
        page.setCurrent(pageNum);
        IPage<ComActWorkGuideVO> iPage = this.baseMapper.pageWorkGuide(page, pageActWorkGuideDTO);
        return R.ok(iPage);
    }

    @Override
    public R delectWorkGuide(Long workGuideId) {
        this.baseMapper.deleteById(workGuideId);
        workGuideMaterialDAO.delete(new LambdaQueryWrapper<ComActWorkGuideMaterialDO>()
                .eq(ComActWorkGuideMaterialDO::getWorkGuideId, workGuideId));
        return R.ok();
    }
}