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

package com.diagbot.facade;

import java.io.InputStream;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.client.UserServiceClient;
import com.diagbot.dto.GetAllConceptDTO;
import com.diagbot.dto.GetAllInformationDTO;
import com.diagbot.dto.GetConceptInfoDetailDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.entity.Concept;
import com.diagbot.entity.LibraryDetail;
import com.diagbot.entity.LibraryInfo;
import com.diagbot.entity.Medical;
import com.diagbot.entity.Relation;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.LibraryInfoService;
import com.diagbot.service.impl.ConceptServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.DateUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.util.UserUtils;
import com.diagbot.vo.AddConceptInfoDetailVO;
import com.diagbot.vo.AddConceptInfoVO;
import com.diagbot.vo.GetAllConceptVO;
import com.diagbot.vo.GetAllInformationVO;
import com.diagbot.vo.GetConceptInfoDetailVO;
import com.diagbot.vo.RemoveConceptInfoVO;

/**
 * @Description: 术语查询业务层
 * @author: Weixuan Huang
 * @time: 2019/1/14 16:17
 */
@Component
public class ConceptFacade extends ConceptServiceImpl {

    @Autowired
    private LibraryInfoFacade libraryinfoFacade;
    @Autowired
    private LibraryDetailFacade libraryDetailFacade;
    @Autowired
    private MedicalFacade medicalFacade;
    @Autowired
    private RelationFacade relationFacade;
    @Autowired
    @Qualifier("libraryInfoServiceImpl")
    private LibraryInfoService libraryInfoService;
    @Autowired
    private UserServiceClient userServiceClient;
    
    /**
     * 获取所有医学术语命名
     * @param getAllConceptVO
     * @return
     */
    public List<GetAllConceptDTO> getAllConcept(GetAllConceptVO getAllConceptVO){
    	QueryWrapper<LibraryInfo> libraryInfoQe = new QueryWrapper<LibraryInfo>();
    	libraryInfoQe.eq("is_deleted", "N");
    	if(getAllConceptVO.getIsConcept()!=null){
    		libraryInfoQe.eq("is_concept", getAllConceptVO.getIsConcept());
    	}
    	if(StringUtil.isNotBlank(getAllConceptVO.getName())){
    		libraryInfoQe.like("name", getAllConceptVO.getName());
    	}
    	
    	List<LibraryInfo> libraryInfoList = libraryinfoFacade.list(libraryInfoQe);
    	
    	if(getAllConceptVO.getIsConcept()!=null&&getAllConceptVO.getIsConcept()==1){
    		QueryWrapper<Concept> conceptQe = new QueryWrapper<>();
    		conceptQe.eq("is_deleted", "N");
    		conceptQe.in("id", libraryInfoList.stream().map(i->i.getConceptId()).distinct().collect(Collectors.toList()));
    		Map<Long,Concept> conceptMap = list(conceptQe).stream().collect(Collectors.toMap(Concept::getId, i->i));
    		
    		libraryInfoList.forEach(i->{
    			if(conceptMap.get(i.getConceptId())==null||conceptMap.get(i.getConceptId()).getLibId()!=i.getId()){
    				i.setIsDeleted("Y");
    			}
    		});
    	}
    	
    	List<GetAllConceptDTO> getAllConceptDTOList = BeanUtil.listCopyTo(libraryInfoList.stream().filter(i->i.getIsDeleted().equals("N")).collect(Collectors.toList()), GetAllConceptDTO.class);
    	getAllConceptDTOList.forEach(i->{
    		i.setNameAndType(i.getName()+"("+i.getType()+")");
    	});
    	
    	return getAllConceptDTOList;
    }
    
    /**
     * 获取医学术语命名列表
     * @param getAllInformationVO
     * @return
     */
    public IPage<GetAllInformationDTO> getAllInformation(GetAllInformationVO getAllInformationVO) {
    	IPage<GetAllInformationDTO> ipage = libraryinfoFacade.getAllInformation(getAllInformationVO);
    	List<String> ids = ipage.getRecords().stream().map(i->i.getOperName()).distinct().collect(Collectors.toList());
    	RespDTO<Map<String, String>> respDTO = userServiceClient.getUserInfoByIds(ids);
    	if (respDTO == null || !CommonErrorCode.OK.getCode().equals(respDTO.code)) {
            throw new CommonException(CommonErrorCode.RPC_ERROR,
                    "获取用户信息失败");
        }
    	ipage.getRecords().forEach(i->{
    		i.setOperName(respDTO.data.get(i.getOperName()));
    	});
        return ipage;
    }
    
    /**
     * 医学术语命名删除
     * @param removeConceptInfoVO
     * @return
     */
    public Boolean removeConceptInfo(RemoveConceptInfoVO removeConceptInfoVO) {
    	StringBuffer sbf = new StringBuffer();
    	
    	QueryWrapper<Medical> medicalQe = new QueryWrapper<Medical>();
    	medicalQe.eq("is_deleted", "N");
    	medicalQe.eq("concept_id", removeConceptInfoVO.getConceptId());
    	if(medicalFacade.list(medicalQe).size()>0){
    		sbf.append("请先解除医学属性关联 ");
    	}
    	
    	QueryWrapper<Relation> relationQe = new QueryWrapper<Relation>();
    	relationQe.eq("is_deleted", "N");
    	relationQe.and(i->i.eq("start_id", removeConceptInfoVO.getConceptId()).or().eq("end_id", removeConceptInfoVO.getConceptId()));
    	if(relationFacade.list(relationQe).size()>0){
    		sbf.append("请先解除术语关系关联 ");
    	}
    	
    	QueryWrapper<LibraryDetail> libraryDetailQe = new QueryWrapper<LibraryDetail>();
    	libraryDetailQe.eq("is_deleted", "N");
    	libraryDetailQe.eq("concept_id", removeConceptInfoVO.getConceptId());
    	if(libraryDetailFacade.list(libraryDetailQe).size()>0){
    		sbf.append("请先解除医学静态知识关联 ");
    	}
    	
    	if(sbf.length()>0){
    		throw new CommonException(CommonErrorCode.RPC_ERROR,sbf.toString());
    	}
    	
    	String currentUser = UserUtils.getCurrentPrincipleID();
    	Date now = DateUtil.now(); 
    	
    	QueryWrapper<LibraryInfo> libraryInfoQe = new QueryWrapper<LibraryInfo>();
    	libraryInfoQe.eq("concept_id", removeConceptInfoVO.getConceptId());
    	LibraryInfo libraryInfo = new LibraryInfo();
    	libraryInfo.setIsDeleted("Y");
    	libraryInfo.setGmtModified(now);
    	libraryInfo.setModifier(currentUser);
    	libraryinfoFacade.update(libraryInfo, libraryInfoQe);
    	
    	Concept concept = new Concept();
    	concept.setId(removeConceptInfoVO.getConceptId());
    	concept.setIsDeleted("Y");
    	concept.setModifier(currentUser);
    	concept.setGmtModified(now);
    	this.updateById(concept);
    	
        return true;
    }
    
    /**
     * 获取医学术语命名详情
     * @param getConceptInfoDetailVO
     * @return 1-标准术语，0-同义词
     */
    public Map<String,List<GetConceptInfoDetailDTO>> getConceptInfoDetail(GetConceptInfoDetailVO getConceptInfoDetailVO){
    	QueryWrapper<LibraryInfo> libraryInfoQe = new QueryWrapper<LibraryInfo>();
    	libraryInfoQe.eq("concept_id", getConceptInfoDetailVO.getConceptId());
    	libraryInfoQe.eq("is_deleted", "N");
    	libraryInfoQe.orderByAsc("order_no");
    	List<LibraryInfo> libraryInfoList = libraryinfoFacade.list(libraryInfoQe);
    	
    	Map<String,List<GetConceptInfoDetailDTO>> retMap = new HashMap<>();
    	retMap.put("otherNames", BeanUtil.listCopyTo(libraryInfoList.stream().filter(i->i.getIsConcept()==null||i.getIsConcept()==0).collect(Collectors.toList()), GetConceptInfoDetailDTO.class));
    	retMap.put("libName", BeanUtil.listCopyTo(libraryInfoList.stream().filter(i->i.getIsConcept()!=null&&i.getIsConcept()==1).collect(Collectors.toList()), GetConceptInfoDetailDTO.class));
    	
    	return retMap;
    }
    
    /**
     * 医学术语命名添加或者编辑
     * @param addConceptInfoVO
     * @return
     */
    @SuppressWarnings("unchecked")
	public Boolean addConceptInfo(AddConceptInfoVO addConceptInfoVO){
    	Map<String,Object> ckMap = checkAddConceptInfoVO(addConceptInfoVO);
    	Object message = ckMap.get("message");
    	if(message!=null){
    		throw new CommonException(CommonErrorCode.RPC_ERROR,message.toString());
    	}
    	
    	saveConceptInfos((List<LibraryInfo>)ckMap.get("libraryInfoList"));
    	
    	return true;
    }
    
    /**
     * 医学术语命名保存
     * @param libraryInfoList
     * @return
     */
    private void saveConceptInfos(List<LibraryInfo> saveOrUpdateLibraryInfoList){
    	if(ListUtil.isNotEmpty(saveOrUpdateLibraryInfoList)){
    		libraryInfoService.saveOrUpdateBatch(saveOrUpdateLibraryInfoList);
    	}
    }
    
    /**
     * 校验即将添加的数据
     * @param addConceptInfoVO
     * @return 返回map中，包含2个字段：message和libraryInfoList，message-为空时，表示正常，取LibraryInfo的集合libraryInfoList
     */
    private Map<String,Object> checkAddConceptInfoVO(AddConceptInfoVO addConceptInfoVO){
    	Map<String,Object> retMap = new HashMap<>();
    	
    	List<AddConceptInfoDetailVO> addConceptInfoDetailVOMainList = addConceptInfoVO.getDetailList().stream().filter(i->i.getIsConcept()==1).collect(Collectors.toList());
    	if(addConceptInfoDetailVOMainList.size()==0){
    		retMap.put("message", "无标准术语");
    		return retMap;
    	}
    	if(addConceptInfoDetailVOMainList.size()>1){
    		retMap.put("message", "标准术语只能有一个");
    		return retMap;
    	}
    	
    	List<LibraryInfo> saveOrUpdateLibraryInfoList = new ArrayList<>();
    	
    	AddConceptInfoDetailVO addConceptInfoDetailVOMain = addConceptInfoDetailVOMainList.get(0);//提交过来的标准术语
    	
    	StringBuffer sbf = new StringBuffer();
    	
    	QueryWrapper<LibraryInfo> libraryInfoQe = new QueryWrapper<LibraryInfo>();
    	libraryInfoQe.eq("type", addConceptInfoVO.getType());
    	libraryInfoQe.in("name", addConceptInfoVO.getDetailList().stream().map(i->i.getName()).collect(Collectors.toList()));
    	Map<String,LibraryInfo> libraryInfoMap = libraryinfoFacade.list(libraryInfoQe).stream().collect(Collectors.toMap(LibraryInfo::getName, i->i));
    	
    	LibraryInfo libraryInfoMain = libraryInfoMap.get(addConceptInfoDetailVOMain.getName());
    	if(libraryInfoMain!=null&&libraryInfoMain.getIsDeleted().equals("N")&&libraryInfoMain.getIsConcept()==0){
    		retMap.put("message", "标准术语已被占用");
    		return retMap;
    	}
    	
		for(AddConceptInfoDetailVO i:addConceptInfoVO.getDetailList()){
			if(i.getIsConcept()==1){
				continue;
			}
			LibraryInfo libraryInfo = libraryInfoMap.get(i.getName());
			if(libraryInfo!=null){
				if(libraryInfo.getIsDeleted().equals("N")&&(libraryInfoMain == null||libraryInfo.getConceptId()!=libraryInfoMain.getConceptId())){
					sbf.append(i.getName()).append(" ");
					continue;
				}
				libraryInfo.setIsDeleted("N");
				libraryInfo.setRemark(i.getRemark());
			}else{
				libraryInfo = new LibraryInfo();
				BeanUtil.copyProperties(i, libraryInfo);
			}
			saveOrUpdateLibraryInfoList.add(libraryInfo);
		}
		
		if(sbf.length()>0){
			sbf.append("已被占用");
			retMap.put("message", sbf.toString());
			return retMap;
		}
		
		Long conceptId = null;
		if(libraryInfoMain==null){
			libraryInfoMain = new LibraryInfo();
			BeanUtil.copyProperties(addConceptInfoDetailVOMain, libraryInfoMain);
			libraryInfoMain.setType(addConceptInfoVO.getType());
			libraryinfoFacade.save(libraryInfoMain);
			Concept concept = new Concept();
			concept.setLibId(libraryInfoMain.getId());
			save(concept);
			conceptId = concept.getId();
		}else{
			libraryInfoMain.setRemark(addConceptInfoDetailVOMain.getRemark());
			Concept concept = new Concept();
			if(libraryInfoMain.getIsDeleted().equals("N")){
				conceptId = libraryInfoMain.getConceptId();
			}else{
				libraryInfoMain.setIsDeleted("N");
				if(libraryInfoMain.getIsConcept()==1){
					concept.setIsDeleted("N");
				}else{
					concept.setLibId(libraryInfoMain.getId());
				}
			}
		}
		
		saveOrUpdateLibraryInfoList.add(libraryInfoMain);
		for(LibraryInfo i : saveOrUpdateLibraryInfoList){
			i.setConceptId(conceptId);
			i.setType(addConceptInfoVO.getType());
		}
		
		retMap.put("libraryInfoList", saveOrUpdateLibraryInfoList);
		
    	return retMap;
    }

    /**
     * 医学术语命名excel文件导入
     * @param file
     * @return
     */
    @SuppressWarnings("unchecked")
	public Boolean conceptInfoExcelIm(MultipartFile file) {
        List<AddConceptInfoVO> addConceptInfoVOList = new ArrayList<>();
        StringBuffer sbf = new StringBuffer();
        InputStream inputStream = null;
        Workbook wb = null;
        try {
            if (!file.isEmpty()) {
                inputStream = file.getInputStream();
                if (inputStream.available() > 512000) {
                    sbf.append("文件最大支持500KB！").append("<br/>");
                } else {
                    String fileName = file.getOriginalFilename();
                    if (fileName.lastIndexOf(".") != -1) {
                        String type = fileName.substring(fileName.lastIndexOf("."));
                        if (type.equals(".xls")) {
                            wb = new HSSFWorkbook(inputStream);
                        } else if (type.equals(".xlsx")) {
                            wb = new XSSFWorkbook(inputStream);
                        }
                        if (wb != null) {
                            
                            Sheet sheet = wb.getSheetAt(0);
                            int count = 0;
                            String libName, libType, otherNames, remark;
                            for (Row row : sheet) {
                                count++;
                                if (count == 1 || row == null) {
                                    continue;
                                }
                                libName = getValue(row.getCell(0)).trim().replace(" ", "");
                                libType = getValue(row.getCell(1)).trim().replace(" ", "");
                                otherNames = getValue(row.getCell(2)).trim().replace(" ", "");
                                remark = getValue(row.getCell(3)).trim().replace(" ", "");
                                if(StringUtil.isEmpty(libName) && StringUtil.isEmpty(libType)
                                        && StringUtil.isEmpty(otherNames) && StringUtil.isEmpty(remark)){
                                	continue;
                                }
                                if (StringUtil.isEmpty(libName) || StringUtil.isEmpty(libType) || StringUtil.isEmpty(otherNames)) {
                                    sbf.append("第" + count + "行数据不完整；").append("<br/>");
                                    continue;
                                }
                                
                                AddConceptInfoVO addConceptInfoVO = new AddConceptInfoVO();
                                addConceptInfoVO.setName(libName);
                                addConceptInfoVO.setType(libType);
                                List<AddConceptInfoDetailVO> detailList = new ArrayList<>();
                                for(String nm:otherNames.split(",")){
                                	if(StringUtil.isBlank(nm)){
                                		continue;
                                	}
                                	AddConceptInfoDetailVO addConceptInfoDetailVO = new AddConceptInfoDetailVO();
                                	addConceptInfoDetailVO.setName(nm);
                                	addConceptInfoDetailVO.setType(libType);
                                	if(libName.equals(nm)){
                                		addConceptInfoDetailVO.setIsConcept(1);
                                		addConceptInfoDetailVO.setRemark(remark);
                                	}else{
                                		addConceptInfoDetailVO.setIsConcept(0);
                                	}
                                	detailList.add(addConceptInfoDetailVO);
                                }
                                addConceptInfoVO.setDetailList(detailList);
                                addConceptInfoVOList.add(addConceptInfoVO);
                            }
                        } else {
                            sbf.append("非excel文件无法解析！").append("<br/>");
                        }
                    } else {
                        sbf.append("未知文件无法解析！").append("<br/>");
                    }
                }
            } else {
                sbf.append("无文件上传！").append("<br/>");
            }
        } catch (Exception e) {
            sbf.append("解析失败！").append("<br/>");
        } finally {
            try {
                if (wb != null) {
                    wb.close();
                }
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (Exception e) {
            }
        }
        
        /*****************excel文件本身问题提醒************************/
        if(sbf.length()>0){
        	throw new CommonException(CommonErrorCode.RPC_ERROR,sbf.toString());
        }
        
        /****************excel文件中所有术语存在重复提示---名字和类型一样即重复***********************/
        List<AddConceptInfoDetailVO> addConceptInfoDetailVOList = new ArrayList<>();
        addConceptInfoVOList.forEach(i->{
        	addConceptInfoDetailVOList.addAll(i.getDetailList());
        });
        Map<String,List<AddConceptInfoDetailVO>> addConceptInfoDetailVOListMap = addConceptInfoDetailVOList.stream().collect(Collectors.groupingBy(AddConceptInfoDetailVO::getName));
        for(String key : addConceptInfoDetailVOListMap.keySet()){
        	if(addConceptInfoDetailVOListMap.get(key).size()>1&&addConceptInfoDetailVOListMap.get(key).stream().map(i->i.getType()).distinct().count()==1){
        		sbf.append(key).append(" ");
        	}
        }
        if(sbf.length()>0){
        	sbf.append("(术语存在重复)");
        	throw new CommonException(CommonErrorCode.RPC_ERROR,sbf.toString());
        }

        /**************校验每一组数据，同时组装*************************/
        List<LibraryInfo> saveOrUpdateLibraryInfoList = new ArrayList<>();
    	Map<String,Object> ckMap = null;
    	Object message = null;
    	for(AddConceptInfoVO i : addConceptInfoVOList){
    		ckMap = checkAddConceptInfoVO(i);
    		message = ckMap.get("message");
    		if(message!=null){
    			sbf.append(message.toString()).append("(标准术语：").append(i.getName()).append(")").append("<br/>");
    		}else{
    			saveOrUpdateLibraryInfoList.addAll((List<LibraryInfo>)ckMap.get("libraryInfoList"));
    		}
    	}
        if(sbf.length()>0){
        	throw new CommonException(CommonErrorCode.RPC_ERROR,sbf.toString());
        }
        
        /******************最终保存***************************/
        saveConceptInfos(saveOrUpdateLibraryInfoList);
        
        return true;
    }
    
    @SuppressWarnings("deprecation")
    private String getValue(Cell cell) {
        try {
            Object obj = null;
            switch (cell.getCellTypeEnum()) {
                case BOOLEAN:
                    obj = cell.getBooleanCellValue();
                    break;
                case ERROR:
                    obj = cell.getErrorCellValue();
                    break;
                case NUMERIC:
                    if (HSSFDateUtil.isCellDateFormatted(cell)) {
                        Date date = cell.getDateCellValue();
                        obj = DateFormatUtils.format(date, "yyyy-MM-dd");
                    } else {
                        obj = cell.getNumericCellValue();
                        DecimalFormat df = new DecimalFormat("0");
                        obj = df.format(obj);
                    }

                    break;
                case STRING:
                    obj = cell.getStringCellValue();
                    break;
                default:
                    break;
            }
            return obj.toString();
        } catch (Exception e) {
            return "";
        }
    }

}