diagbotcloud/knowledgeman-service/src/main/java/com/diagbot/facade/LisMappingFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.client.ICSSManServiceClient;
import com.diagbot.client.UserServiceClient;
import com.diagbot.dto.LisMappingPageDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.entity.Concept;
import com.diagbot.entity.LisMapping;
import com.diagbot.entity.QuestionInfo;
import com.diagbot.entity.wrapper.LisMappingWrapper;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.LexiconTypeEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.impl.LisMappingServiceImpl;
import com.diagbot.util.DateUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.util.UserUtils;
import com.diagbot.vo.GetUniqueNameVO;
import com.diagbot.vo.IdListVO;
import com.diagbot.vo.IdVO;
import com.diagbot.vo.KLQuestionVO;
import com.diagbot.vo.LisMappingPageVO;
import com.diagbot.vo.LisMappingSearch;
import com.diagbot.vo.LisMappingVO;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @Description:
 * @Author:zhaops
 * @time: 2019/9/19 11:42
 */
@Component
public class LisMappingFacade extends LisMappingServiceImpl {
    @Autowired
    private ConceptFacade conceptFacade;
    @Autowired
    private UserServiceClient userServiceClient;
    @Autowired
    private ICSSManServiceClient icssManServiceClient;

    /**
     * 化验公表映射分页信息
     *
     * @param lisMappingPageVO
     * @return
     */
    public IPage<LisMappingPageDTO> getLisMappingPage(LisMappingPageVO lisMappingPageVO) {
        IPage<LisMappingPageDTO> dtoPage = this.lisMappingPage(lisMappingPageVO);
        List<LisMappingPageDTO> records = dtoPage.getRecords();
        List<String> userIds = records.stream().map(record -> record.getModifier()).collect(Collectors.toList());
        RespDTO<Map<String, String>> data = userServiceClient.getUserInfoByIds(userIds);
        Map<String, String> userInfos = data.data;
        for (LisMappingPageDTO record : records) {
            record.setGmtOperate(record.getGmtModified());
            record.setOperator(record.getModifier());
            record.setOperatorName(userInfos.get(record.getModifier()));
        }
        dtoPage.setRecords(records);
        return dtoPage;
    }

    /**
     * 保存化验公表映射关系
     *
     * @param lisMappingVO
     * @return
     */
    public Boolean saveLisMapping(LisMappingVO lisMappingVO) {
        String userId = UserUtils.getCurrentPrincipleID();
        Date now = DateUtil.now();
        LisMapping lisMapping = new LisMapping();
        lisMapping.setCreator(userId);
        lisMapping.setGmtCreate(now);

        //验证医学术语是否存在
        Concept mealConcept = conceptFacade.getById(lisMappingVO.getMealId());
        if (mealConcept == null) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "化验套餐项术语不存在");
        }
        if (lisMappingVO.getItemId() != null && !lisMappingVO.getItemId().equals(0L)) {
            Concept itemConcept = conceptFacade.getById(lisMappingVO.getItemId());
            if (itemConcept == null) {
                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "化验明细项术语不存在");
            }
        }
        Concept uniqueConcept = conceptFacade.getById(lisMappingVO.getUniqueId());
        if (uniqueConcept == null) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "化验公表项项术语不存在");
        }

        QueryWrapper<LisMapping> lisMappingQueryWrapper = new QueryWrapper<>();
        lisMappingQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("meal_id", lisMappingVO.getMealId());
        if (lisMappingVO.getItemId() == null || lisMappingVO.getItemId().equals(0L)) {
            lisMappingQueryWrapper.and(i -> i.isNull("item_id").or(j -> j.eq("item_id", "0")));
        } else {
            lisMappingQueryWrapper.eq("item_id", lisMappingVO.getItemId());
        }
        List<LisMapping> lisMappingList = this.list(lisMappingQueryWrapper);
        if (lisMappingList.size() > 1) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "存在多条映射关系，请删除重复映射");
        } else if (lisMappingList.size() == 1) {
            lisMapping = lisMappingList.get(0);
        }
        lisMapping.setMealId(lisMappingVO.getMealId());
        if (lisMappingVO.getItemId() == null || lisMappingVO.getItemId().equals(0L)) {
            lisMapping.setItemId(0L);
        } else {
            lisMapping.setItemId(lisMappingVO.getItemId());
        }
        lisMapping.setUniqueId(lisMappingVO.getUniqueId());
        lisMapping.setModifier(userId);
        lisMapping.setGmtModified(now);
        lisMapping.setIsDeleted(IsDeleteEnum.N.getKey());
        Boolean state = this.saveOrUpdate(lisMapping);

        //清除缓存
        KLQuestionVO klQuestionVO = new KLQuestionVO();
        List<String> mealNames = Lists.newArrayList();
        mealNames.add(mealConcept.getLibName());
        klQuestionVO.setNames(mealNames);
        klQuestionVO.setTagNames(mealNames);
        klQuestionVO.setType(5);
        List<Integer> tagTypes = Lists.newArrayList();
        tagTypes.add(7);
        klQuestionVO.setTagType(tagTypes);
        RespDTO<List<QuestionInfo>> respDTO = icssManServiceClient.indexForkl(klQuestionVO);
        if (RespDTOUtil.respIsOK(respDTO)) {
            List<QuestionInfo> questionInfoList = respDTO.data;
            if (ListUtil.isNotEmpty(questionInfoList)) {
                IdListVO idListVO = new IdListVO();
                List<Long> idList = questionInfoList.stream().map(i -> i.getId()).collect(Collectors.toList());
                idListVO.setIdList(idList);
                RespDTO<Boolean> cacheRespDTO = icssManServiceClient.clearCache(idListVO);
            }
        }
        return state;
    }

    /**
     * 判断映射关系是否已存在
     *
     * @param lisMappingVO
     * @return
     */
    public Boolean hasLisMapping(LisMappingVO lisMappingVO) {
        QueryWrapper<LisMapping> lisMappingQueryWrapper = new QueryWrapper<>();
        lisMappingQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("meal_id", lisMappingVO.getMealId());
        if (lisMappingVO.getItemId() == null || lisMappingVO.getItemId().equals(0L)) {
            lisMappingQueryWrapper.and(i -> i.isNull("item_id").or(j -> j.eq("item_id", "0")));
        } else {
            lisMappingQueryWrapper.eq("item_id", lisMappingVO.getItemId());
        }
        List<LisMapping> lisMappingList = this.list(lisMappingQueryWrapper);
        if (ListUtil.isNotEmpty(lisMappingList)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 删除单条化验公表映射关系
     *
     * @param idVO
     * @return
     */
    public Boolean delLisMappingById(IdVO idVO) {
        String userId = UserUtils.getCurrentPrincipleID();
        Date now = DateUtil.now();
        LisMapping lisMapping = this.getById(idVO.getId());
        if (lisMapping == null) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "映射关系不存在，不允许删除");
        }
        lisMapping.setIsDeleted(IsDeleteEnum.Y.getKey());
        lisMapping.setModifier(userId);
        lisMapping.setGmtModified(now);
        Boolean state = this.updateById(lisMapping);

        //清除缓存
        Concept mealConcept = conceptFacade.getById(lisMapping.getMealId());
        KLQuestionVO klQuestionVO = new KLQuestionVO();
        List<String> mealNames = Lists.newArrayList();
        mealNames.add(mealConcept.getLibName());
        klQuestionVO.setNames(mealNames);
        klQuestionVO.setTagNames(mealNames);
        klQuestionVO.setType(5);
        List<Integer> tagTypes = Lists.newArrayList();
        tagTypes.add(7);
        klQuestionVO.setTagType(tagTypes);
        RespDTO<List<QuestionInfo>> respDTO = icssManServiceClient.indexForkl(klQuestionVO);
        if (RespDTOUtil.respIsOK(respDTO)) {
            List<QuestionInfo> questionInfoList = respDTO.data;
            if (ListUtil.isNotEmpty(questionInfoList)) {
                IdListVO idListVO = new IdListVO();
                List<Long> idList = questionInfoList.stream().map(i -> i.getId()).collect(Collectors.toList());
                idListVO.setIdList(idList);
                RespDTO<Boolean> cacheRespDTO = icssManServiceClient.clearCache(idListVO);
            }
        }
        return state;
    }


    /**
     * 获取化验公表名称
     *
     * @param getUniqueNameVO
     * @return
     */
    public String getLisUniqueName(GetUniqueNameVO getUniqueNameVO) {
        String uniqueName = "";
        QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
        conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("lib_name", getUniqueNameVO.getMealName())
                .eq("lib_type", LexiconTypeEnum.LIS_PACKAGE.getKey());
        Concept mealConcept = conceptFacade.getOne(conceptQueryWrapper, false);
        if (mealConcept == null) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "化验大项【" + getUniqueNameVO.getMealName() + "】不存在");
        }
        Concept itemConcept = null;
        if (StringUtil.isNotBlank(getUniqueNameVO.getItemName())) {
            conceptQueryWrapper = new QueryWrapper<>();
            conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                    .eq("lib_name", getUniqueNameVO.getItemName())
                    .eq("lib_type", LexiconTypeEnum.LIS_DETAILS.getKey());
            itemConcept = conceptFacade.getOne(conceptQueryWrapper, false);
            if (itemConcept == null) {
                throw new CommonException(CommonErrorCode.NOT_EXISTS, "化验小项【" + getUniqueNameVO.getItemName() + "】不存在");
            }
        }
        QueryWrapper<LisMapping> lisMappingQueryWrapper = new QueryWrapper<>();
        lisMappingQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("meal_id", mealConcept.getId());
        if (itemConcept == null) {
            lisMappingQueryWrapper.and(i -> i.isNull("item_id").or(j -> j.eq("item_id", 0L)));
        } else {
            lisMappingQueryWrapper.eq("item_id", itemConcept.getId());
        }
        List<LisMapping> lisMappingList = this.list(lisMappingQueryWrapper);
        if (ListUtil.isNotEmpty(lisMappingList)) {
            Concept uniqueConcept = conceptFacade.getById(lisMappingList.get(0).getUniqueId());
            if (uniqueConcept != null) {
                uniqueName = uniqueConcept.getLibName();
            }
        }
        return uniqueName;
    }


    /**
     * 根据套餐和明细项获取化验公表
     *
     * @param lisMappingSearchList
     * @return
     */
    public List<LisMappingSearch> getLisUniqueNameWithList(List<LisMappingSearch> lisMappingSearchList) {
        List<LisMappingSearch> res = getUniqueName(lisMappingSearchList);
        if (ListUtil.isNotEmpty(res)) {
            Map<String, String> map = res.stream().collect(Collectors.toMap((r -> r.getMealName() + "__" + r.getItemName()), (r -> r.getUniqueName())));
            for(LisMappingSearch mappingListVO : lisMappingSearchList) {
                mappingListVO.setUniqueName(map.get(mappingListVO.getMealName() + "__" + mappingListVO.getItemName()));
            }
        }
        return lisMappingSearchList;
    }


    /**
     * 加载全部公表项数据
     *
     * @return 返回公表项内容，格式：套餐__明细__公表项
     */
    public Set<String> loadLisMappingFac() {
        return this.loadLisMapping();
    }

    /**
     * 获取化验套餐
     *
     * @param uniqueNames
     * @return
     */
    public List<String> getMealNameByUniqueNames(List<String> uniqueNames) {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("uniqueNames", uniqueNames);
        List<LisMappingWrapper> lisMappingWrapperList = this.getLisMappingByName(paramMap);
        List<String> mealNames = lisMappingWrapperList.stream().map(i -> i.getMealName()).filter(j -> j != null)
                .distinct().collect(Collectors.toList());
        return mealNames;
    }

    /**
     * 获取化验套餐
     *
     * @param itemNames
     * @return
     */
    public List<String> getMealNameByItemNames(List<String> itemNames) {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("itemNames", itemNames);
        List<LisMappingWrapper> lisMappingWrapperList = this.getLisMappingByName(paramMap);
        List<String> mealNames = lisMappingWrapperList.stream().map(i -> i.getMealName())
                .filter(j -> j != null).distinct().collect(Collectors.toList());
        return mealNames;
    }
}