12/23 大屏修改

101captain

2021-12-23 5a8a90c095280fbd2106869ecd2bad10e01a57a6

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

@@ -10,8 +10,12 @@
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.model.dtos.community.OperationDetailDTO;
import com.panzhihua.common.model.dtos.community.reserve.*;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.ComActReserveIndexVo;
import com.panzhihua.common.model.vos.community.bigscreen.IndexBackReserve;
import com.panzhihua.common.model.vos.community.bigscreen.IndexReserve;
import com.panzhihua.common.model.vos.community.questnaire.QuestnaiteSubSelectionVO;
import com.panzhihua.common.model.vos.community.questnaire.QuestnaiteSubVO;
import com.panzhihua.common.model.vos.community.reserve.*;
@@ -26,6 +30,7 @@
import com.panzhihua.service_community.dao.*;
import com.panzhihua.service_community.model.dos.*;
import com.panzhihua.service_community.service.ComActReserveAnswerContentService;
import com.panzhihua.service_community.service.ComActReserveRecordService;
import com.panzhihua.service_community.service.ComActReserveService;
import com.panzhihua.service_community.service.ComActReserveSubSelectionService;
import lombok.extern.slf4j.Slf4j;
@@ -34,6 +39,10 @@
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
@@ -68,6 +77,8 @@
    private ComActReserveOperationRecordMapper comActReserveOperationRecordMapper;
    @Resource
    private ComActReserveSubSelectionService comActReserveSubSelectionService;
    @Resource
    private ComActReserveRecordService comActReserveRecordService;

    private final static String COMMIT="用户已提交";
    @Override
@@ -80,8 +91,17 @@
            ComActReserveDO comActReserveDO=comActReserveMapper.selectById(comActReserveCommitVO.getId());
            if(comActReserveDO!=null){
                //查询当前用户是否已预约并判断是否能继续预约
                if(comActReserveDO.getJoinAllCount()!=0){
                    Integer count=comActReserveRecordMapper.selectCount(new QueryWrapper<ComActReserveRecordDO>()
                            .eq("reserve_id",comActReserveCommitVO.getId())
                            .eq("status",ComActReserveRecordDO.status.cg));
                    if(count>=comActReserveDO.getJoinAllCount()){
                        return R.fail("预约已上限");
                    }
                }

                List<ComActReserveRecordDO> list=comActReserveRecordMapper.selectList(new QueryWrapper<ComActReserveRecordDO>().eq("reserve_id",comActReserveCommitVO.getId()).eq("user_id",comActReserveCommitVO.getUserId()).in("status",1,2,3));
                if(!list.isEmpty()&&comActReserveDO.getIsRepeat()==ComActReserveDO.isRepeat.no){
                if(!list.isEmpty()&&list.size()>1&&comActReserveDO.getIsRepeat()==ComActReserveDO.isRepeat.no){
                    return R.fail("提交失败，不可重复预约");
                }
                else {
@@ -100,7 +120,7 @@

                            Long queSubId = questnaireSubDO.getId();
                            //根据上传的类型查询不同的题目选项
                            if(questnaiteSub.getType().equals(QuestnaiteSubVO.type.danxuan)){
                            if(questnaiteSub.getType().equals(QuestnaiteSubVO.type.danxuan) || questnaiteSub.getType().equals(QuestnaiteSubVO.type.imgselect)){

                                //单选题处理
                                ComActReserveSubSelectionDO subSelectionDO = comActReserveSubSelectionMapper.selectOne(new QueryWrapper<ComActReserveSubSelectionDO>()
@@ -144,31 +164,35 @@
                                    answerContentDO.setAnswerContent(subSelectionDO.getContent());
                                    answerContentList.add(answerContentDO);
                                }
                            }else if(questnaiteSub.getType().equals(QuestnaiteSubVO.type.wenda)){
                                //问答题处理
                                String values = questnaiteSub.getValues();
                                ComActReserveAnswerContentDO answerContentDO = new ComActReserveAnswerContentDO();
                                answerContentDO.setUserId(userId);
                                answerContentDO.setCreateAt(nowDate);
                                answerContentDO.setCreateBy(userId);
                                answerContentDO.setReserveSubId(queSubId);
                                answerContentDO.setType(2);
                                answerContentDO.setAnswerContent(values);
                                answerContentList.add(answerContentDO);
                            }else{
                                //文字描述不做处理
                                if(!questnaiteSub.getType().equals(QuestnaiteSubVO.type.describe)){
                                    //问答题处理
                                    String values = questnaiteSub.getValues();
                                    ComActReserveAnswerContentDO answerContentDO = new ComActReserveAnswerContentDO();
                                    answerContentDO.setUserId(userId);
                                    answerContentDO.setCreateAt(nowDate);
                                    answerContentDO.setCreateBy(userId);
                                    answerContentDO.setReserveSubId(queSubId);
                                    answerContentDO.setType(2);
                                    answerContentDO.setAnswerContent(values);
                                    answerContentList.add(answerContentDO);
                                }
                            }
                        }
                        if(!answerContentList.isEmpty()){
                            comActReserveAnswerContentService.saveBatch(answerContentList);

                            //更新回答用户数量
                            Integer joinCount = comActReserveDO.getJoinCount();
                            comActReserveDO.setJoinCount(joinCount != null ? joinCount + 1 : 1);
                            comActReserveMapper.updateById(comActReserveDO);

                            //新增用户答题记录
                            ComActReserveRecordDO userAnswerDO = new ComActReserveRecordDO();
                            userAnswerDO.setContent(comActReserveCommitVO.getContent());
                            userAnswerDO.setName(comActReserveCommitVO.getName());
                            userAnswerDO.setCommunityId(comActReserveCommitVO.getCommunityId());
                            userAnswerDO.setPhone(comActReserveCommitVO.getPhone());
                            userAnswerDO.setReserveId(questId);
                            userAnswerDO.setReserveTime(comActReserveCommitVO.getReserveTime());
                            userAnswerDO.setUserId(userId);
                            userAnswerDO.setType(comActReserveCommitVO.getType());
                            userAnswerDO.setCreateAt(nowDate);
@@ -179,21 +203,155 @@
                            else {
                                userAnswerDO.setStatus(ComActReserveRecordDO.status.cg);
                            }
                            comActReserveRecordMapper.insert(userAnswerDO);
                            comActReserveRecordService.saveOrUpdate(userAnswerDO);

                            //给答题记录赋值预约登记记录id
                            answerContentList.forEach(answerContent -> {
                                answerContent.setReserveRecordId(userAnswerDO.getId());
                            });
                            comActReserveAnswerContentService.saveBatch(answerContentList);
                            //新增用户操作记录
                            ComActReserveOperationRecordDO comActReserveOperationRecordDO=new ComActReserveOperationRecordDO();
                            comActReserveOperationRecordDO.setReserveId(comActReserveCommitVO.getId());
                            comActReserveOperationRecordDO.setReserveRecordId(userAnswerDO.getId());
                            comActReserveOperationRecordDO.setType(ComActReserveOperationRecordDO.type.br);
                            comActReserveOperationRecordDO.setReserveTime(DateUtil.date());
                            comActReserveOperationRecordDO.setCreateAt(DateUtil.date());
                            comActReserveOperationRecordDO.setReserveTime(comActReserveCommitVO.getReserveTime());
                            comActReserveOperationRecordDO.setReserveContent(COMMIT);
                            comActReserveOperationRecordDO.setPhone(comActReserveCommitVO.getPhone());
                            comActReserveOperationRecordDO.setStatus(ComActReserveOperationRecordDO.status.ytj);
                            comActReserveOperationRecordDO.setUserId(comActReserveCommitVO.getUserId());
                            comActReserveOperationRecordDO.setRemark(comActReserveCommitVO.getContent());
                            comActReserveOperationRecordMapper.insert(comActReserveOperationRecordDO);
                        return R.ok("提交成功");
                        }
                    }
                }

            }
        }
        return R.fail("参数错误");
    }

    @Override
    public R commitNoToken(ComActReserveCommitVO comActReserveCommitVO) {
        if(comActReserveCommitVO!=null){
            ComActReserveDO comActReserveDO=new ComActReserveDO();
            Date nowDate=DateUtil.date();
            //查询预约登记记录
            List<ComActReserveDO> list=comActReserveMapper.selectList(new QueryWrapper<ComActReserveDO>().lambda().eq(ComActReserveDO::getCommunityId,comActReserveCommitVO.getCommunityId()).eq(ComActReserveDO::getTitle,"返攀登记"));
            if(!list.isEmpty()){
                comActReserveDO=list.get(0);
            }
            comActReserveCommitVO.setId(comActReserveDO.getId());
            if(comActReserveDO!=null){
                    List<QuestnaiteSubVO> questnaiteSubVOS = JSON.parseArray(comActReserveCommitVO.getJsonObject(),QuestnaiteSubVO.class);
                    if(!questnaiteSubVOS.isEmpty()){
                        Long questId=comActReserveCommitVO.getId();
                        List<ComActReserveAnswerContentDO> answerContentList=new ArrayList<>();
                        for(QuestnaiteSubVO questnaiteSub:questnaiteSubVOS){
                            //查询用户填写题目
                            ComActReserveSubDO questnaireSubDO = comActReserveSubMapper.selectOne(new QueryWrapper<ComActReserveSubDO>().lambda()
                                    .eq(ComActReserveSubDO::getReserveId,questId).eq(ComActReserveSubDO::getKey,questnaiteSub.getKey()));
                            if(questnaireSubDO == null){
                                log.error("未查询到调查问卷题目，题目名称：" + questnaiteSub.getLabel() + "题目key：" + questnaiteSub.getKey());
                                continue;
                            }
                            Long queSubId = questnaireSubDO.getId();
                            //根据上传的类型查询不同的题目选项
                            if(questnaiteSub.getType().equals(QuestnaiteSubVO.type.danxuan) || questnaiteSub.getType().equals(QuestnaiteSubVO.type.imgselect)){
                                //单选题处理
                                ComActReserveSubSelectionDO subSelectionDO = comActReserveSubSelectionMapper.selectOne(new QueryWrapper<ComActReserveSubSelectionDO>()
                                        .lambda().eq(ComActReserveSubSelectionDO::getReserveSubId,queSubId).eq(ComActReserveSubSelectionDO::getReserveId,questId)
                                        .eq(ComActReserveSubSelectionDO::getKey,questnaiteSub.getValues()));
                                if(subSelectionDO == null){
                                    log.error("未查询到调查问卷选项，题目名称：" + questnaiteSub.getLabel() + "选项key：" + questnaiteSub.getValues());
                                    continue;
                                }

                                ComActReserveAnswerContentDO answerContentDO = new ComActReserveAnswerContentDO();
                                answerContentDO.setCreateAt(nowDate);
                                answerContentDO.setReserveSelectionId(subSelectionDO.getId());
                                answerContentDO.setReserveSubId(queSubId);
                                answerContentDO.setType(1);
                                answerContentDO.setChoice(subSelectionDO.getOptionName());
                                answerContentDO.setAnswerContent(subSelectionDO.getContent());
                                answerContentList.add(answerContentDO);
                            }else if(questnaiteSub.getType().equals(QuestnaiteSubVO.type.duoxuan)){
                                //多选题处理
                                String values = questnaiteSub.getValues();
                                String []value = values.split(",");
                                for (int i = 0; i < value.length; i++) {
                                    ComActReserveSubSelectionDO subSelectionDO = comActReserveSubSelectionMapper.selectOne(new QueryWrapper<ComActReserveSubSelectionDO>()
                                            .lambda().eq(ComActReserveSubSelectionDO::getReserveSubId,queSubId).eq(ComActReserveSubSelectionDO::getReserveId,questId)
                                            .eq(ComActReserveSubSelectionDO::getKey,value[i]));
                                    if(subSelectionDO == null){
                                        log.error("未查询到调查问卷选项，题目名称：" + questnaiteSub.getLabel() + "选项key：" + questnaiteSub.getValues());
                                        continue;
                                    }
                                    ComActReserveAnswerContentDO answerContentDO = new ComActReserveAnswerContentDO();
                                    answerContentDO.setCreateAt(nowDate);
                                    answerContentDO.setReserveSelectionId(subSelectionDO.getId());
                                    answerContentDO.setReserveSubId(queSubId);
                                    answerContentDO.setType(1);
                                    answerContentDO.setChoice(subSelectionDO.getOptionName());
                                    answerContentDO.setAnswerContent(subSelectionDO.getContent());
                                    answerContentList.add(answerContentDO);
                                }
                            }else{
                                //文字描述不做处理
                                if(!questnaiteSub.getType().equals(QuestnaiteSubVO.type.describe)){
                                    //问答题处理
                                    String values = questnaiteSub.getValues();
                                    ComActReserveAnswerContentDO answerContentDO = new ComActReserveAnswerContentDO();
                                    answerContentDO.setCreateAt(nowDate);
                                    answerContentDO.setReserveSubId(queSubId);
                                    answerContentDO.setType(2);
                                    answerContentDO.setAnswerContent(values);
                                    answerContentList.add(answerContentDO);
                                }
                            }
                        }
                        if(!answerContentList.isEmpty()){
                            //更新回答用户数量
                            Integer joinCount = comActReserveDO.getJoinCount();
                            comActReserveDO.setJoinCount(joinCount != null ? joinCount + 1 : 1);
                            comActReserveMapper.updateById(comActReserveDO);
                            //新增用户答题记录
                            ComActReserveRecordDO userAnswerDO = new ComActReserveRecordDO();
                            userAnswerDO.setContent(comActReserveCommitVO.getContent()!=null?comActReserveCommitVO.getContent():"");
                            userAnswerDO.setName(comActReserveCommitVO.getName()!=null?comActReserveCommitVO.getName():"");
                            userAnswerDO.setCommunityId(comActReserveCommitVO.getCommunityId());
                            userAnswerDO.setPhone(comActReserveCommitVO.getPhone()!=null?comActReserveCommitVO.getPhone():"");
                            userAnswerDO.setReserveId(questId);
                            userAnswerDO.setReserveTime(comActReserveCommitVO.getReserveTime()!=null?comActReserveCommitVO.getReserveTime():new Date());
                            userAnswerDO.setType(comActReserveCommitVO.getType()!=null? comActReserveCommitVO.getType() : 2);
                            userAnswerDO.setCreateAt(nowDate);
                            userAnswerDO.setJsonObject(comActReserveCommitVO.getJsonObject());
                            userAnswerDO.setStatus(ComActReserveRecordDO.status.cg);
                            comActReserveRecordService.saveOrUpdate(userAnswerDO);

                            //给答题记录赋值预约登记记录id
                            answerContentList.forEach(answerContent -> {
                                answerContent.setReserveRecordId(userAnswerDO.getId());
                            });
                            comActReserveAnswerContentService.saveBatch(answerContentList);
                            //新增用户操作记录
                            ComActReserveOperationRecordDO comActReserveOperationRecordDO=new ComActReserveOperationRecordDO();
                            comActReserveOperationRecordDO.setReserveId(comActReserveCommitVO.getId());
                            comActReserveOperationRecordDO.setReserveRecordId(userAnswerDO.getId());
                            comActReserveOperationRecordDO.setType(ComActReserveOperationRecordDO.type.br);
                            comActReserveOperationRecordDO.setCreateAt(DateUtil.date());
                            comActReserveOperationRecordDO.setReserveTime(comActReserveCommitVO.getReserveTime());
                            comActReserveOperationRecordDO.setReserveContent(COMMIT);
                            //comActReserveOperationRecordDO.setPhone(comActReserveCommitVO.getPhone());
                            comActReserveOperationRecordDO.setStatus(ComActReserveOperationRecordDO.status.ytj);
                            //comActReserveOperationRecordDO.setRemark(comActReserveCommitVO.getContent());
                            comActReserveOperationRecordMapper.insert(comActReserveOperationRecordDO);
                            return R.ok("提交成功");
                        }
                    }


            }
        }
@@ -286,6 +444,7 @@
                    subSelectionDO.setCreateAt(nowDate);
                    subSelectionDO.setType(subSelect.getType());
                    subSelectionDO.setKey(subSelect.getKey());
                    subSelectionDO.setUrl(subSelect.getUrl());
                    subSelectionList.add(subSelectionDO);
                }
            }
@@ -539,7 +698,115 @@
    }

    @Override
    public R getById(Long id,Long userId,Long recordId,Integer isBack) {
        ComActReserveDO comActReserveDO=comActReserveMapper.selectById(id);
        if(comActReserveDO!=null){
            comActReserveDO.setViewNum(comActReserveDO.getViewNum()+1);
            ComActReserveDetailVO comActReserveDetailVO=new ComActReserveDetailVO();
            if(isBack!=1){
                comActReserveDO.setViewNum(comActReserveDO.getViewNum()+1);
                BeanUtils.copyProperties(comActReserveDO,comActReserveDetailVO);
                List<ComActReserveRecordDO> list=comActReserveRecordMapper.selectList(new QueryWrapper<ComActReserveRecordDO>().eq("user_id",userId).eq("reserve_id",id).in("status",1,2).orderByDesc("create_at"));
                List<ComActReserveRecordDO> secondlist=comActReserveRecordMapper.selectList(new QueryWrapper<ComActReserveRecordDO>().eq("user_id",userId).eq("reserve_id",id).orderByDesc("create_at"));
                //判断当前数据是否可重复提交
                if(comActReserveDO.getIsRepeat()==ComActReserveDetailVO.isOk.y||list.isEmpty()){
                    comActReserveDetailVO.setIsOk(ComActReserveDetailVO.isOk.n);
                }else {
                    comActReserveDetailVO.setIsOk(ComActReserveDetailVO.isOk.y);
                }
                //如果用户已提交返回最新一条记录 列表时间倒序排列
                if(!list.isEmpty()){
                    comActReserveDetailVO.setJsonObject(list.get(0).getJsonObject());
                    comActReserveDetailVO.setReserveTime(list.get(0).getReserveTime());
                }
                if(!secondlist.isEmpty()&&recordId!=null){
                    secondlist.forEach(comActReserveRecordDO -> {
                        if(comActReserveRecordDO.getId().equals(recordId)){
                            comActReserveDetailVO.setRecordStatus(comActReserveRecordDO.getStatus());
                        }
                    });
                }
                //更新浏览量
                comActReserveMapper.updateById(comActReserveDO);
                return R.ok(comActReserveDetailVO);
            }
            ComActReserveRecordDO comActReserveRecordDO =comActReserveRecordMapper.selectById(recordId);
            if(comActReserveRecordDO!=null){
                BeanUtils.copyProperties(comActReserveRecordDO,comActReserveDetailVO);
            }
            //更新浏览量
            comActReserveMapper.updateById(comActReserveDO);
            return R.ok(comActReserveDetailVO);
        }
        return R.fail("未查询到数据");

    }

    @Override
    public R pageReserveList(PageUserReserveDTO pageUserReserveDTO) {
        return R.ok(comActReserveRecordMapper.pageReserveList(new Page<ComActReserveDO>(pageUserReserveDTO.getPageNum(), pageUserReserveDTO.getPageSize()),pageUserReserveDTO));
        IPage<ComActReserveAppletsVO> ipage = comActReserveRecordMapper.pageReserveList(new Page<>(pageUserReserveDTO.getPageNum(), pageUserReserveDTO.getPageSize()),pageUserReserveDTO);
        OperationDetailDTO operationDetailDTO = new OperationDetailDTO();
        ipage.getRecords().forEach(page -> {
            operationDetailDTO.setReserveRecordId(page.getId());
            List<ComOperationListVO> operationList = comActReserveRecordMapper.queryAll(operationDetailDTO);
            page.setOperationList(operationList);
        });
        return R.ok(ipage);
    }

    /**
     * 小程序查询所有进行中的预约登记
     * @param communityId   社区id
     * @return  社区所有进行中的预约登记列表
     */
    @Override
    public R reserveListApplets(Long communityId){
        return R.ok(this.baseMapper.getReserveIndexList(communityId));
    }

    @Override
    public IndexReserve indexReserve(Long communityId) {
        List<ComActReserveDO> comActReserveDOS=this.comActReserveMapper.selectList(new QueryWrapper<ComActReserveDO>().lambda().eq(ComActReserveDO::getCommunityId,communityId).orderByDesc(ComActReserveDO::getCreateAt).like(ComActReserveDO::getTitle,"返攀登记").eq(ComActReserveDO::getStatus,ComActReserveDO.status.jxz));
        if(!comActReserveDOS.isEmpty()){
            IndexBackReserve indexBackReserve=new IndexBackReserve();
            indexBackReserve.setCount(this.comActReserveRecordMapper.selectCount(new QueryWrapper<ComActReserveRecordDO>().lambda().eq(ComActReserveRecordDO::getReserveId,comActReserveDOS.get(0).getId())));

        }

        return null;
    }


    public static void getFileByBytes(byte[] bytes, String filePath, String fileName) {
        BufferedOutputStream bos = null;
        FileOutputStream fos = null;
        File file = null;
        try {
            File dir = new File(filePath);
            if (!dir.exists()) {// 判断文件目录是否存在
                dir.mkdirs();
            }
            file = new File(filePath + fileName);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}