diagbotcloud/icss-service/src/main/java/com/diagbot/facade/InquiryInfoFacade.java

package com.diagbot.facade;

import java.io.IOException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import com.diagbot.util.IntegerUtil;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.diagbot.client.TranServiceClient;
import com.diagbot.dto.GetEvaluationScalesDTO;
import com.diagbot.dto.GetEvaluationsDTO;
import com.diagbot.dto.GetExportInquirysDTO;
import com.diagbot.dto.GetInquiryDetailDTO;
import com.diagbot.dto.GetLastOtherDTO;
import com.diagbot.dto.HisInquiryDTO;
import com.diagbot.dto.HisInquirysForDjDTO;
import com.diagbot.dto.HisInquirysForJzDTO;
import com.diagbot.dto.HospitalInfoDTO;
import com.diagbot.dto.PatientInfoDTO;
import com.diagbot.dto.ReadInquiryDTO;
import com.diagbot.dto.ReadInquiryDrugDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.dto.SaveInquiryDTO;
import com.diagbot.entity.DoctorInfo;
import com.diagbot.entity.HospitalDept;
import com.diagbot.entity.InquiryDetail;
import com.diagbot.entity.InquiryDrug;
import com.diagbot.entity.InquiryEvaluation;
import com.diagbot.entity.InquiryInfo;
import com.diagbot.entity.InquiryScale;
import com.diagbot.entity.PatientInfo;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.SexTypeEnum;
import com.diagbot.enums.SysTypeEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.InquiryDetailService;
import com.diagbot.service.InquiryDrugService;
import com.diagbot.service.InquiryScaleService;
import com.diagbot.service.impl.InquiryInfoServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.DateUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.AddDiagnoseSecondVO;
import com.diagbot.vo.ExportInquirysVO;
import com.diagbot.vo.GetEvaluationScalesVO;
import com.diagbot.vo.GetEvaluationsVO;
import com.diagbot.vo.GetInquiryDetailVO;
import com.diagbot.vo.GetLastOtherVO;
import com.diagbot.vo.HisInquirysForDjVO;
import com.diagbot.vo.HisInquirysForJzVO;
import com.diagbot.vo.HisInquirysVO;
import com.diagbot.vo.IndexDataSaveVO;
import com.diagbot.vo.PatientInfoVO;
import com.diagbot.vo.ReadInquiryVO;
import com.diagbot.vo.SaveInquiryToHisVO;
import com.diagbot.vo.SaveInquiryVO;

/**
 * @author rengb
 * @Description
 * @time 2018年11月23日下午2:08:08
 */
@Component
public class InquiryInfoFacade extends InquiryInfoServiceImpl {

    @Autowired
    private InquiryDetailFacade inquiryDetailFacade;
    @Autowired
    @Qualifier("inquiryDetailServiceImpl")
    private InquiryDetailService inquiryDetailService;
    @Autowired
    private HospitalInfoFacade hospitalInfoFacade;
    @Autowired
    private PatientInfoFacade patientInfoFacade;
    @Autowired
    private DoctorInfoFacade doctorInfoFacade;
    @Autowired
    private HospitalDeptFacade hospitalDeptFacade;
    @Autowired
    private TranServiceClient tranServiceClient;
    @Autowired
    private InquiryDrugFacade inquiryDrugFacade;
    @Autowired
    @Qualifier("inquiryDrugServiceImpl")
    private InquiryDrugService inquiryDrugService;
    @Autowired
    private InquiryEvaluationFacade inquiryEvaluationFacade;
    @Autowired
    private InquiryScaleFacade inquiryScaleFacade;
    @Autowired
    @Qualifier("inquiryScaleServiceImpl")
    private InquiryScaleService inquiryScaleService;
    @Autowired
    private IndexDataFacade indexDataFacade;

    /**
     * 问诊记录保存
     *
     * @param saveInquiryVO
     * @return
     */
    public SaveInquiryDTO saveInquiry(SaveInquiryVO saveInquiryVO) {
        SaveInquiryDTO saveInquiryDTO = new SaveInquiryDTO();
        Date now = DateUtil.now();

        QueryWrapper<InquiryInfo> inquiryInfoQe = new QueryWrapper<>();
        inquiryInfoQe.eq("is_deleted", IsDeleteEnum.N.getKey());
        inquiryInfoQe.eq("hospital_id", saveInquiryVO.getHospitalId());
        inquiryInfoQe.eq("hospital_dept_id", saveInquiryVO.getHospitalDeptId());
        inquiryInfoQe.eq("doctor_id", saveInquiryVO.getDoctorId());
        inquiryInfoQe.eq("patient_id", saveInquiryVO.getPatientId());
        inquiryInfoQe.eq("inquiry_code", saveInquiryVO.getInquiryCode());
        InquiryInfo inquiryInfo = getOne(inquiryInfoQe);

        if (inquiryInfo == null) {
        	inquiryInfo = new InquiryInfo();
        	inquiryInfo.setGmtCreate(now);
        } else {
            inquiryDetailFacade.removeByInquiryId(inquiryInfo.getId());
            inquiryDrugFacade.removeByInquiryId(inquiryInfo.getId());
            inquiryEvaluationFacade.removeByInquiryId(inquiryInfo.getId());
            inquiryScaleFacade.removeByInquiryId(inquiryInfo.getId());
        }
        inquiryInfo.setGmtModified(now);
        BeanUtil.copyProperties(saveInquiryVO, inquiryInfo);
        this.saveOrUpdate(inquiryInfo);

        Long inquiryId = inquiryInfo.getId();
        if (ListUtil.isNotEmpty(saveInquiryVO.getDetailList())) {
            List<InquiryDetail> inquiryDetailList = BeanUtil.listCopyTo(saveInquiryVO.getDetailList(), InquiryDetail.class);
            inquiryDetailList.forEach(i->{
            	i.setInquiryId(inquiryId);
                i.setGmtCreate(now);
                i.setGmtModified(now);
            });
            inquiryDetailService.saveBatch(inquiryDetailList);
        }

        if (ListUtil.isNotEmpty(saveInquiryVO.getDrugList())) {
            List<InquiryDrug> inquiryDrugList = BeanUtil.listCopyTo(saveInquiryVO.getDrugList(), InquiryDrug.class);
            inquiryDrugList.forEach(i -> {
                i.setInquiryId(inquiryId);
                i.setGmtCreate(now);
                i.setGmtModified(now);
            });
            inquiryDrugService.saveBatch(inquiryDrugList);
        }

        if (saveInquiryVO.getInquiryEvaluation() != null) {
            InquiryEvaluation inquiryEvaluation = new InquiryEvaluation();
            inquiryEvaluation.setInquiryId(inquiryId);
            inquiryEvaluation.setGmtCreate(now);
            inquiryEvaluation.setGmtModified(now);
            inquiryEvaluation.setHtmlContent(saveInquiryVO.getInquiryEvaluation().getHtmlContent());
            inquiryEvaluationFacade.save(inquiryEvaluation);

            if (ListUtil.isNotEmpty(saveInquiryVO.getInquiryEvaluation().getScaleList())) {
                List<InquiryScale> inquiryScaleList = BeanUtil.listCopyTo(saveInquiryVO.getInquiryEvaluation().getScaleList(), InquiryScale.class);
                inquiryScaleList.forEach(i -> {
                    i.setInquiryId(inquiryId);
                    i.setInquiryEvaluationId(inquiryEvaluation.getId());
                    i.setGmtCreate(now);
                    i.setGmtModified(now);
                });
                inquiryScaleService.saveBatch(inquiryScaleList);
            }
        }
        //指标信息保存
        if (ListUtil.isNotEmpty(saveInquiryVO.getIndexData())) {
            IndexDataSaveVO indexDataSaveVO = new IndexDataSaveVO();
            BeanUtil.copyProperties(saveInquiryVO, indexDataSaveVO);
            indexDataFacade.saveIndexDatas(indexDataSaveVO);
        }

        SaveInquiryToHisVO saveInquiryToHisVO = new SaveInquiryToHisVO();
        BeanUtil.copyProperties(saveInquiryVO, saveInquiryToHisVO);
        saveInquiryToHisVO.setSysType(SysTypeEnum.ICSS_SERVICE.getKey());
        RespDTOUtil.respNGDeal(tranServiceClient.saveInquiryToHis(saveInquiryToHisVO), "问诊记录插入tran层失败");

        saveInquiryDTO.setInquiryId(inquiryId);
        
        return saveInquiryDTO;
    }

    /**
     * 问诊记录回显
     *
     * @param readInquiryVO
     * @return
     */
    public ReadInquiryDTO readInquiry(ReadInquiryVO readInquiryVO) {
        ReadInquiryDTO readInquiryDTO = new ReadInquiryDTO();
        QueryWrapper<InquiryInfo> queryWrapper = new QueryWrapper<InquiryInfo>();
        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
        queryWrapper.eq("hospital_id", readInquiryVO.getHospitalId());
        queryWrapper.eq("hospital_dept_id", readInquiryVO.getHospitalDeptId());
        queryWrapper.eq("doctor_id", readInquiryVO.getDoctorId());
        queryWrapper.eq("patient_id", readInquiryVO.getPatientId());
        queryWrapper.eq("inquiry_code", readInquiryVO.getInquiryCode());
        InquiryInfo inquiryInfo = this.getOne(queryWrapper);

        if (inquiryInfo != null) {
            //readInquiryDTO.setDataJson(inquiryInfo.getDataJson());
            BeanUtil.copyProperties(inquiryInfo, readInquiryDTO);

            QueryWrapper<InquiryDetail> inquiryDetailQe = new QueryWrapper<>();
            inquiryDetailQe.eq("inquiry_id", inquiryInfo.getId());
            readInquiryDTO.setDetailList(inquiryDetailFacade.list(inquiryDetailQe).stream().sorted((a, b) -> a.getType() - b.getType()).collect(Collectors.toList()));

            List<InquiryDrug> inquiryDrugList = inquiryDrugFacade.getInquiryDrugs(inquiryInfo.getId());

            List<ReadInquiryDrugDTO> drugList = BeanUtil.listCopyTo(inquiryDrugList, ReadInquiryDrugDTO.class);
            readInquiryDTO.setDrugList(drugList);

            QueryWrapper<InquiryEvaluation> inquiryEvaluationQe = new QueryWrapper<>();
            inquiryEvaluationQe.eq("inquiry_id", inquiryInfo.getId());
            readInquiryDTO.setInquiryEvaluation(inquiryEvaluationFacade.getOne(inquiryEvaluationQe));

            QueryWrapper<InquiryScale> inquiryScaleQe = new QueryWrapper<>();
            inquiryScaleQe.eq("inquiry_id", inquiryInfo.getId());
            readInquiryDTO.setInquiryScaleList(inquiryScaleFacade.list(inquiryScaleQe));
        }

        return readInquiryDTO;
    }

    /**
     * 获取最近一次其他史信息
     *
     * @param getLastOtherVO
     * @return
     */
    public GetLastOtherDTO getLastOther(GetLastOtherVO getLastOtherVO) {
        GetLastOtherDTO getLastOtherDTO = new GetLastOtherDTO();

        HospitalInfoDTO hospitalInfoDTO = hospitalInfoFacade.getHospitalByCode(getLastOtherVO.getHospitalCode());

        PatientInfoVO patientInfoVO = new PatientInfoVO();
        patientInfoVO.setHospitalCode(getLastOtherVO.getHospitalCode());
        patientInfoVO.setPatientCode(getLastOtherVO.getPatientCode());
        PatientInfoDTO patientInfoDTO = patientInfoFacade.getPatientInfo(patientInfoVO);

        Map<String, Object> map = new HashMap<>();
        map.put("hospitalId", hospitalInfoDTO.getId());
        map.put("patientId", patientInfoDTO.getId());
        if (!IntegerUtil.isNull(getLastOtherVO.getSign())){
            map.put("sign", getLastOtherVO.getSign());
        }
        InquiryInfo inquiryInfo = baseMapper.getPatientLast(map);

        if (inquiryInfo != null) {
            getLastOtherDTO.setDataJson(inquiryInfo.getDataJson());

            QueryWrapper<InquiryDetail> inquiryDetailQe = new QueryWrapper<>();
            inquiryDetailQe.eq("inquiry_id", inquiryInfo.getId());
            inquiryDetailQe.eq("type", 3);
            InquiryDetail inquiryDetail = inquiryDetailFacade.getOne(inquiryDetailQe);
            if (inquiryDetail != null) {
                getLastOtherDTO.setOtherStr(inquiryDetail.getContent());
            }
        }
        return getLastOtherDTO;
    }

    /**
     * 历史病历列表
     *
     * @param hisInquirysVO
     * @return
     */
    public IPage<HisInquiryDTO> hisInquirys(HisInquirysVO hisInquirysVO) {
    	Page<HisInquiryDTO> hisInquiryDTOPage = new Page<>();
    	
        QueryWrapper<InquiryInfo> inquiryInfoQe = new QueryWrapper<>();
        inquiryInfoQe.eq("is_deleted", IsDeleteEnum.N.getKey());
        inquiryInfoQe.eq("hospital_id", hisInquirysVO.getHospitalId());
        inquiryInfoQe.eq(hisInquirysVO.getHospitalDeptId() != null, "hospital_dept_id", hisInquirysVO.getHospitalDeptId());
        inquiryInfoQe.eq(hisInquirysVO.getDoctorId() != null, "doctor_id", hisInquirysVO.getDoctorId());
        inquiryInfoQe.eq(hisInquirysVO.getPatientId() != null, "patient_id", hisInquirysVO.getPatientId());
        inquiryInfoQe.eq(hisInquirysVO.getType() != null, "type", hisInquirysVO.getType());
        inquiryInfoQe.eq(hisInquirysVO.getSign() != null, "sign", hisInquirysVO.getSign());
        inquiryInfoQe.ge(hisInquirysVO.getStartDate() != null, "gmt_create", hisInquirysVO.getStartDate());
        inquiryInfoQe.le(hisInquirysVO.getEndDate() != null, "gmt_create", hisInquirysVO.getEndDate());
        inquiryInfoQe.orderByDesc(hisInquirysVO.getOrderType() == 1,"gmt_modified");
        inquiryInfoQe.orderByAsc(hisInquirysVO.getOrderType() == 2, "gmt_modified");
        
        if (hisInquirysVO.getDisType() == 1) {
            Date nowDate = DateUtil.now();
            Date lastDate = DateUtil.addMonth(nowDate, -6);
            inquiryInfoQe.ge("gmt_create", lastDate);
            inquiryInfoQe.le("gmt_create", nowDate);
            inquiryInfoQe.likeRight("diagnose", hisInquirysVO.getDisName());
        }

        Page<InquiryInfo> inquiryInfoPage = new Page<>(hisInquirysVO.getCurrent(),hisInquirysVO.getSize());
        IPage<InquiryInfo> iPage = this.page(inquiryInfoPage, inquiryInfoQe);
    	BeanUtil.copyProperties(iPage, hisInquiryDTOPage);
        
        List<InquiryInfo> inquiryInfoList = iPage.getRecords();
        if (inquiryInfoList.size() == 0) {
            return null;
        }

        List<Long> hospitalDeptIdList = inquiryInfoList.stream().map(i -> i.getHospitalDeptId()).distinct().collect(Collectors.toList());
        List<Long> doctorIdList = inquiryInfoList.stream().map(i -> i.getDoctorId()).distinct().collect(Collectors.toList());
        List<Long> patientIdList = inquiryInfoList.stream().map(i -> i.getPatientId()).distinct().collect(Collectors.toList());
        List<Long> inquiryIdList = inquiryInfoList.stream().map(i -> i.getId()).distinct().collect(Collectors.toList());

        Map<Long, HospitalDept> hospitalDeptMap = hospitalDeptFacade.hospitalDeptInfoMapByIds(hospitalDeptIdList);
        Map<Long, DoctorInfo> doctorInfoMap = doctorInfoFacade.doctorInfoMapByIds(doctorIdList);
        Map<Long, PatientInfo> patientInfoMap = patientInfoFacade.patientInfoMapByIds(patientIdList);
        Map<Long, List<InquiryDetail>> inquiryDetailMap = inquiryDetailFacade.getDetailsByInquryIds(inquiryIdList);

        List<HisInquiryDTO> hisInquiryDTOList = new ArrayList<>();
        inquiryInfoList.forEach(i -> {
            HisInquiryDTO hisInquiryDTO = new HisInquiryDTO();
            BeanUtil.copyProperties(i, hisInquiryDTO);
            hisInquiryDTO.setInquiryDate(i.getGmtModified());
            hisInquiryDTO.setInquiryTime(i.getGmtModified());
            hisInquiryDTO.setHospitalDeptName(Optional.ofNullable(hospitalDeptMap.get(i.getHospitalDeptId())).map(t -> t.getName()).orElse(null));
            hisInquiryDTO.setDoctorName(Optional.ofNullable(doctorInfoMap.get(i.getDoctorId())).map(t -> t.getName()).orElse(null));
            PatientInfo patientInfo = patientInfoMap.get(i.getPatientId());
            if (patientInfo != null) {
                hisInquiryDTO.setPatientName(patientInfo.getName());
                hisInquiryDTO.setPatientIdNo(patientInfo.getIdNo());
                hisInquiryDTO.setPatientSex(SexTypeEnum.getName(patientInfo.getSex()));
                hisInquiryDTO.setPatientAge(DateUtil.yearCompare(patientInfo.getBirthday(), DateUtil.now()));
            }

            hisInquiryDTO.setDetailList(inquiryDetailMap.get(i.getId()));
            hisInquiryDTOList.add(hisInquiryDTO);
        });

        hisInquiryDTOPage.setRecords(hisInquiryDTOList);
        return hisInquiryDTOPage;
    }
    
    /**
     * 急诊-历史病历列表
     * 
     * @param hisInquirysForJzVO
     * @return
     */
    public HisInquirysForJzDTO hisInquirysForJz(HisInquirysForJzVO hisInquirysForJzVO){
    	RespDTO<HisInquirysForJzDTO> res = tranServiceClient.hisInquirysForJz(hisInquirysForJzVO);
    	RespDTOUtil.respNGDeal(res, "获取急诊历史病历列表失败");
    	return res.data;
    }
    
    /**
     * 对接-历史病历列表
     * 
     * @param hisInquirysForDjVO
     * @return
     */
    public List<HisInquirysForDjDTO> hisInquirysForDj(HisInquirysForDjVO hisInquirysForDjVO) {
        QueryWrapper<InquiryInfo> queryWrapper = new QueryWrapper<InquiryInfo>();
        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
        queryWrapper.eq("hospital_id", hisInquirysForDjVO.getHospitalId());
        if (hisInquirysForDjVO.getHospitalDeptId() != null) {
            queryWrapper.eq("hospital_dept_id", hisInquirysForDjVO.getHospitalDeptId());
        }
        if (hisInquirysForDjVO.getDoctorId() != null) {
            queryWrapper.eq("doctor_id", hisInquirysForDjVO.getDoctorId());
        }
        if (hisInquirysForDjVO.getPatientId() != null) {
            queryWrapper.eq("patient_id", hisInquirysForDjVO.getPatientId());
        }
        if (StringUtil.isNotBlank(hisInquirysForDjVO.getInquiryCode())) {
            queryWrapper.eq("inquiry_code", hisInquirysForDjVO.getInquiryCode());
        }
        if (hisInquirysForDjVO.getType() != null) {
            queryWrapper.eq("type", hisInquirysForDjVO.getType());
        }
        if (hisInquirysForDjVO.getSign() != null) {
            queryWrapper.eq("sign", hisInquirysForDjVO.getSign());
        }
        if (hisInquirysForDjVO.getStartDate() != null) {
            queryWrapper.ge("gmt_create", hisInquirysForDjVO.getStartDate());
        }
        if (hisInquirysForDjVO.getEndDate() != null) {
            queryWrapper.le("gmt_create", hisInquirysForDjVO.getEndDate());
        }
        if (hisInquirysForDjVO.getOrderType() == 1) {
            queryWrapper.orderByDesc("gmt_modified");
        } else if (hisInquirysForDjVO.getOrderType() == 2) {
            queryWrapper.orderByAsc("gmt_modified");
        }
        List<InquiryInfo> inquiryInfoList = this.list(queryWrapper);
        if (ListUtil.isEmpty(inquiryInfoList)) {
            return null;
        }

        Map<Long, List<InquiryDetail>> inquiryDetailMap = inquiryDetailFacade.getDetailsByInquryIds(inquiryInfoList.stream().map(i -> i.getId()).collect(Collectors.toList()));
        List<HisInquirysForDjDTO> hisInquirysForDjDTOList = BeanUtil.listCopyTo(inquiryInfoList, HisInquirysForDjDTO.class);

        hisInquirysForDjDTOList.forEach(i -> {
            i.setContentList(inquiryDetailMap.get(i.getId()).stream().map(k -> k.getContentValue()).collect(Collectors.toList()));
        });

        return hisInquirysForDjDTOList;
    }


    /**
     * 病历详情
     *
     * @param getInquiryDetailVO
     * @return
     */
    public GetInquiryDetailDTO getInquiryDetail(GetInquiryDetailVO getInquiryDetailVO) {
        GetInquiryDetailDTO getInquiryDetailDTO = new GetInquiryDetailDTO();
        
        InquiryInfo inquiryInfo = this.getById(getInquiryDetailVO.getInquiryId());
        List<InquiryDetail> inquiryDetailList = inquiryDetailFacade.getListByInquryId(getInquiryDetailVO.getInquiryId());
        
        getInquiryDetailDTO.setDataJson(inquiryInfo.getDataJson());
        getInquiryDetailDTO.setDetailList(inquiryDetailList);

        return getInquiryDetailDTO;
    }

    /**
     * 获取评估结果
     *
     * @param getEvaluationsVO
     * @return
     */
    public List<GetEvaluationsDTO> getEvaluations(GetEvaluationsVO getEvaluationsVO) {
        List<InquiryEvaluation> inquiryEvaluationList = inquiryEvaluationFacade.getEvaluationsByInquiryId(getEvaluationsVO.getInquiryId());
        return BeanUtil.listCopyTo(inquiryEvaluationList, GetEvaluationsDTO.class);
    }

    /**
     * 获取评估量表
     *
     * @param getEvaluationScalesVO
     * @return
     */
    public List<GetEvaluationScalesDTO> getEvaluationScales(GetEvaluationScalesVO getEvaluationScalesVO) {
        QueryWrapper<InquiryScale> queryWrapper = new QueryWrapper<InquiryScale>();
        queryWrapper.eq("inquiry_id", getEvaluationScalesVO.getInquiryId());
        queryWrapper.eq("inquiry_evaluation_id", getEvaluationScalesVO.getInquiryEvaluationId());
        List<InquiryScale> inquiryScaleList = inquiryScaleFacade.list(queryWrapper);
        return BeanUtil.listCopyTo(inquiryScaleList, GetEvaluationScalesDTO.class);
    }
    
    /**
     * 急诊-添加二次诊断
     * 
     * @param addDiagnoseSecondVO
     * @return
     */
    public Boolean addDiagnoseSecond(AddDiagnoseSecondVO addDiagnoseSecondVO){
    	RespDTO<Boolean> res = tranServiceClient.addDiagnoseSecond(addDiagnoseSecondVO);
    	RespDTOUtil.respNGDeal(res, "添加二次诊断失败");
    	return res.data;
    }
    
    public void exportInquirys(HttpServletResponse response,ExportInquirysVO exportInquirysVO){
    	RespDTO<List<GetExportInquirysDTO>> res = tranServiceClient.getExportInquirys(exportInquirysVO.getInquiryIds());
    	RespDTOUtil.respNGDeal(res, "导出病历失败");
    	List<GetExportInquirysDTO> getExportInquirysDTOList = res.data;
    	HSSFWorkbook workbook = null;
    	ServletOutputStream outputStream = null;
    	try{
        	workbook = new HSSFWorkbook();
        	HSSFSheet sheet = workbook.createSheet("统计表");
        	
        	String[] headers={"序号","性别","年龄","主诉","现病史","其他史","查体","化验","辅检","医嘱","诊断","二次诊断*"};
        	HSSFRow headRow = sheet.createRow(0);
        	for (int i =0;i <headers.length;i++){
        		headRow.createCell(i).setCellValue(headers[i]);
        	}
        	
        	int rowNum=1;
        	for(GetExportInquirysDTO getExportInquirysDTO : getExportInquirysDTOList){
        		HSSFRow row=sheet.createRow(rowNum);
        		row.createCell(0).setCellValue(getExportInquirysDTO.getLineNum());
        		row.createCell(1).setCellValue(getExportInquirysDTO.getPatientSex());
        		row.createCell(2).setCellValue(getExportInquirysDTO.getPatientAge());
        		for(int type=1;type<=9;type++){
        			row.createCell(type+2).setCellValue(getExportInquirysDTO.getDetailMap().get(type));
        		}
        		rowNum++;
        	}
        	
        	String fileName = "data.xls";
            response.setContentType("application/vnd.ms-excel");
            response.setHeader("Content-Disposition", "attachment;filename="+URLEncoder.encode(fileName, "utf-8"));
            outputStream = response.getOutputStream();
            workbook.write(outputStream);
            outputStream.close();
        } catch (Exception e){
        	throw new CommonException(CommonErrorCode.SERVER_IS_ERROR);
        } finally {
        	try {
        		if(workbook!=null){
        			workbook.close();
        		}
        	} catch (IOException e) {
        		e.printStackTrace();
        	}
		}
    }
    

}