diagbotcloud/prec-service/src/main/java/com/diagbot/facade/QuestionFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.diagbot.dto.QuestionDTO;
import com.diagbot.entity.QuestionDetail;
import com.diagbot.entity.QuestionInfo;
import com.diagbot.entity.wrapper.QuestionInfoWrapper;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.service.impl.QuestionInfoServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.vo.QuestionIds2VO;
import com.diagbot.vo.QuestionVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description: 标签业务层
 * @author: zhoutg
 * @time: 2018/8/6 9:11
 */
@Component
public class QuestionFacade extends QuestionInfoServiceImpl {

    @Autowired
    QuestionDetailFacade questionDetailFacade;

    /**
     * 根据参数返回标签内容
     *
     * @param questionVO 获取标签内容参数
     * @return 标签内容
     */
    public QuestionDTO getById(QuestionVO questionVO) {
        Map paramMap = new HashMap<>();
        paramMap.put("sexType", questionVO.getSexType());
        paramMap.put("age", questionVO.getAge());
        paramMap.put("id", questionVO.getId());
        QuestionInfo questionInfo = this.getByParam(paramMap);
        if (questionInfo == null) { //无数据直接返回，不通过报错的形式返回
            return new QuestionDTO();
        }
        QuestionDTO res = new QuestionDTO();
        BeanUtil.copyProperties(questionInfo, res);

        if (questionInfo.getTagType().equals(1)) {
            //获取明细项
            List<QuestionDetail> questionDetailList = questionDetailFacade.getByQuestionId(questionVO.getId());
            res.setQuestionDetailList(questionDetailList);
        }

        //获取子标签
        List<QuestionInfoWrapper> questionMapping = this.getByQuestionMapping(paramMap);
        List<QuestionDTO> sonQuestionList = BeanUtil.listCopyTo(questionMapping, QuestionDTO.class);
        res.setQuestionMapping(sonQuestionList);
        //获取子标签的明细项
        if (ListUtil.isNotEmpty(sonQuestionList)) {
            Map paramMap1 = new HashMap<>();
            paramMap1.put("sexType", questionVO.getSexType());
            paramMap1.put("age", questionVO.getAge());
            List<Long> sonQuestionIds = sonQuestionList.stream()
                    .map(artist -> artist.getId())
                    .collect(Collectors.toList());
            Map<Long, List<QuestionDetail>> sonQuestionMap = questionDetailFacade.getByQuestionIds(sonQuestionIds);
            paramMap1.put("ids", sonQuestionIds);
            //获取第二级子标签
            List<QuestionInfoWrapper> questionMapping1 = this.getByQuestionMapping(paramMap1);
            Map<Long, List<QuestionInfoWrapper>> qm1 =
                    EntityUtil.makeEntityListMap(questionMapping1, "parentQuestion");
            for (QuestionDTO bean : sonQuestionList) {
                List<QuestionDetail> questionDetailList1 = sonQuestionMap.get(bean.getId());
                if (ListUtil.isEmpty(questionDetailList1)) {
                    questionDetailList1 = new ArrayList<>();
                }
                bean.setQuestionDetailList(questionDetailList1);
                List<QuestionDTO> sonQuestionList1 = new ArrayList<>();
                if (ListUtil.isNotEmpty(qm1.get(bean.getId()))) {
                    sonQuestionList1 = BeanUtil.listCopyTo(qm1.get(bean.getId()), QuestionDTO.class);
                }
                bean.setQuestionMapping(sonQuestionList1);

                List<Long> sonQuestionIds1 = sonQuestionList1.stream()
                        .map(artist -> artist.getId())
                        .collect(Collectors.toList());
                Map<Long, List<QuestionDetail>> sonQuestionMap1 = questionDetailFacade.getByQuestionIds(sonQuestionIds1);
                for (QuestionDTO questionDTO : sonQuestionList1) {
                    //获取二级子明细项
                    List<QuestionDetail> questionDetailList2 = sonQuestionMap1.get(questionDTO.getId());
                    if (ListUtil.isEmpty(questionDetailList2)) {
                        questionDetailList2 = new ArrayList<>();
                    }
                    questionDTO.setQuestionDetailList(questionDetailList2);
                }

            }
        }
        return res;
    }


    /**
     * 查询多个id返回标签内容
     *
     * @param questionIds2VO 获取标签内容参数
     * @return 标签内容
     */
    public Map<Long, Object> getByIds(QuestionIds2VO questionIds2VO) {
        Integer sexType = questionIds2VO.getSexType();
        Integer age = questionIds2VO.getAge();
        Map<Long, Object> data = new LinkedHashMap<>();
        if (ListUtil.isEmpty(questionIds2VO.getIds())) {
            return data;
        }

        Map paramMap = new HashMap<>();
        paramMap.put("sexType", sexType);
        paramMap.put("age", age);
        paramMap.put("idList", questionIds2VO.getIds());

        List<QuestionInfo> questionInfoList = this.getByParam2(paramMap);
        List<Long> questionId = questionInfoList.stream().map(r -> r.getId()).collect(Collectors.toList());

        // 获取第一层明细项
        Map<Long, List<QuestionDetail>> detailMap = getQuestionDetailWithMap(questionInfoList.stream()
                .filter(r -> r.getTagType() == 1).map(r -> r.getId()).collect(Collectors.toList()));

        // 获取第二层mapping和明细项
        List<Long> ques2 = new ArrayList<>();
        Map<Long, List<QuestionInfoWrapper>> mapping2 = getQuestionMappingWithMap(sexType, age, questionId, ques2);
        Map<Long, List<QuestionDetail>> detailMap2 = getQuestionDetailWithMap(ques2);

        // 获取第三层mapping和明细项
        List<Long> ques3 = new ArrayList<>();
        Map<Long, List<QuestionInfoWrapper>> mapping3 = new HashMap<>();
        Map<Long, List<QuestionDetail>> detailMap3 = new HashMap<>();
        if (!ListUtil.isEmpty(ques2)) {
            mapping3 = getQuestionMappingWithMap(sexType, age, ques2, ques3);
            detailMap3 = getQuestionDetailWithMap(ques3);
        }

        for (QuestionInfo questionInfo : questionInfoList) {
            QuestionDTO res = new QuestionDTO();
            BeanUtil.copyProperties(questionInfo, res);
            // 设置第一层明细
            if (detailMap.get(res.getId()) != null) {
                res.setQuestionDetailList(detailMap.get(res.getId()));
            }

            // 设置第二层mapping
            List<QuestionInfoWrapper> w2 = mapping2.get(res.getId());
            if (ListUtil.isNotEmpty(w2)) {
                List<QuestionDTO> m2 = BeanUtil.listCopyTo(w2, QuestionDTO.class);
                res.setQuestionMapping(m2);
                for (QuestionDTO q2 : m2) {
                    // 设置第二层明细
                    if (detailMap2.get(q2.getId()) != null) {
                        q2.setQuestionDetailList(detailMap2.get(q2.getId()));
                    }
                    List<QuestionInfoWrapper> w3 = mapping3.get(q2.getId());
                    if (ListUtil.isNotEmpty(w3)) {
                        // 设置第三层mapping
                        List<QuestionDTO> m3 = BeanUtil.listCopyTo(w3, QuestionDTO.class);
                        q2.setQuestionMapping(m3);
                        for (QuestionDTO q3 : m3) {
                            // 设置第三层明细
                            if (detailMap3.get(q3.getId()) != null) {
                                q3.setQuestionDetailList(detailMap3.get(q3.getId()));
                            }
                        }
                    }
                }
            }
            data.put(res.getId(), res);
        }
        return data;
    }


    /**
     * 根据questionIds获取明细
     *
     * @param questionIds
     * @return
     */
    public Map<Long, List<QuestionDetail>> getQuestionDetailWithMap(List<Long> questionIds) {
        if (ListUtil.isEmpty(questionIds)) {
            return new LinkedHashMap<>();
        }

        List<QuestionDetail> detailList = questionDetailFacade.list(new QueryWrapper<QuestionDetail>()
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .in("question_id", questionIds)
                .orderByAsc("order_no"));
        Map<Long, List<QuestionDetail>> detailMap =
                EntityUtil.makeEntityListMap(detailList, "questionId");
        return detailMap;
    }


    /**
     * 获取下级question
     *
     * @param sexType 性别
     * @param age     年龄
     * @param ids     列表
     * @return
     */
    public Map getQuestionMappingWithMap(Integer sexType, Integer age, List<Long> ids, List<Long> mappIds) {
        Map paramMap = new HashMap<>();
        paramMap.put("sexType", sexType);
        paramMap.put("age", age);
        paramMap.put("ids", ids);
        List<QuestionInfoWrapper> questionMapping1 = this.getByQuestionMapping(paramMap);
        List<Long> list = questionMapping1.stream().map(r -> r.getId()).collect(Collectors.toList());
        mappIds.addAll(list);
        return EntityUtil.makeEntityListMap(questionMapping1, "parentQuestion");
    }

}