fj-dc/.svn/pristine/84/8448f1d22944bbf09d7e47cd75d2c584e598c766.svn-base

package cn.com.goldenwater.dcproj.service.impl.importex;

import cn.com.goldenwater.core.service.AbstractCrudService;
import cn.com.goldenwater.dcproj.constValue.ImpPblmEnum;
import cn.com.goldenwater.dcproj.dao.*;
import cn.com.goldenwater.dcproj.dto.BisInspRgstrDto;
import cn.com.goldenwater.dcproj.dto.BisInspRsvrRgstrPcDto;
import cn.com.goldenwater.dcproj.dto.BisInspSdRgstrDto;
import cn.com.goldenwater.dcproj.dto.PersListDto;
import cn.com.goldenwater.dcproj.model.*;
import cn.com.goldenwater.dcproj.param.*;
import cn.com.goldenwater.dcproj.service.BisInspAllRlationPersService;
import cn.com.goldenwater.dcproj.service.BisInspPblmService;
import cn.com.goldenwater.dcproj.service.GwComFileService;
import cn.com.goldenwater.dcproj.service.ImpPblmService;
import cn.com.goldenwater.dcproj.util.PtypeConversionUtil;
import cn.com.goldenwater.dcproj.utils.InspUtils;
import cn.com.goldenwater.dcproj.utils.ZipUtil;
import cn.com.goldenwater.dcproj.utils.export.FieldFormat;
import cn.com.goldenwater.dcproj.utils.impexcel.ExpAndImpUtil;
import cn.com.goldenwater.dcproj.utils.impexcel.ExpUtil;
import cn.com.goldenwater.dcproj.utils.impexcel.ImpUtil;
import cn.com.goldenwater.dcproj.utils.impexcel.ImportExcel;
import cn.com.goldenwater.dcproj.utils.impexcel.format.PblmFieldFormatExp;
import cn.com.goldenwater.dcproj.utils.impexcel.format.PblmFieldFormatImp;
import cn.com.goldenwater.id.util.UuidUtil;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageInfo;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

import static cn.com.goldenwater.dcproj.constValue.ImpPblmEnum.*;
import static cn.com.goldenwater.dcproj.utils.impexcel.ImpUtil.*;
import static cn.com.goldenwater.dcproj.utils.impexcel.ImportExcel.convertMapToBean;
import static cn.com.goldenwater.dcproj.utils.impexcel.field.ExcelFieldLists.pblmFieldArrays;

/**
 * <p>
 *  水库问题导入Service实现类，业务逻辑主要处理部分
 *      1）rollbackFor属性 只要有异常就会回滚
 * </p>
 *
 * @author liyz
 * @date 2019/7/10 16:10
 **/
@Service
@Transactional(rollbackFor = Exception.class)
public class ImpPblmServiceImpl extends AbstractCrudService implements ImpPblmService {

    @Value("${export.templatePath}")
    private  String templatePath;
    @Value("${impExcel.basePath}")
    private String impExcelBashPath;
    @Value("${web.upload-path}")
    private String imgPath;
    @Value("${getFile.prefix}")
    private String imgPathPrefix;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private ImpPblmDao impPblmDao;
    @Autowired
    private GwComFileService gwComFileService;
    @Autowired
    private BisInspPblmService bisInspPblmService;
    @Autowired
    private ObjInspPblmsDao objInspPblmsDao;
    @Autowired
    private ObjKeyPblmsDao objKeyPblmsDao;
    @Autowired
    private BisInspRsvrRgstrDao bisInspRsvrRgstrDao;
    @Autowired
    private BisInspSvwtAreaRgstrDao bisInspSvwtAreaRgstrDao;
    @Autowired
    private BisInspSvwtWuntRgstrDao bisInspSvwtWuntRgstrDao;
    @Autowired
    private BisInspPblmDao bisInspPblmDao;
    @Autowired
    private AttWagaRgstrDao attWagaRgstrDao;
    @Autowired
    private BisInspSdRgstrDao bisInspSdRgstrDao;
    @Autowired
    private BisInspSwhsRgstrDao bisInspSwhsRgstrDao;
    @Autowired
    private BisInspWiuRgstrDao bisInspWiuRgstrDao;
    @Autowired
    private BisInspAllObjDao bisInspAllObjDao;
    @Autowired
    private BisInspKeyRegisterSectionDao bisInspKeyRegisterSectionDao;
    @Autowired
    private BisInspAllRlationPersService bisInspAllRlationPersService;


    private int updateSuccessCount = 0;
    private int insertSuccessCount = 0;

    /**
     * 要检查问题标准的类型
     */
    private static String[] checkedOrgTypes = new String[]{
            ImpPblmEnum.IMP_REVER.getOrgType(),
            ImpPblmEnum.IMP_WAGA.getOrgType(),
            ImpPblmEnum.IMP_SD.getOrgType(),
            ImpPblmEnum.IMP_SWHS.getOrgType(),
            ImpPblmEnum.IMP_WIU.getOrgType()
    };


    public ImpPblmServiceImpl(ImpPblmDao impPblmDao) {
        super(impPblmDao);
        this.impPblmDao = impPblmDao;
    }


    @Override
    public void downloadTemplate(HttpServletResponse response,String userId,String orgType,String orgIds,String datas,String orgId) throws Exception{
//        if(orgType.equals(orgIds)){
//            orgIds = "";
//        }
        ImpPblmEnum impPblmEnum  = ImpPblmEnum.getEnumByOrgType(orgType);
        if(impPblmEnum == null){
            return;
        }
        switch (impPblmEnum) {
            case IMP_REVER:
                // 水库
                this.downloadTemplateRever(response, userId, orgType, orgIds ,datas,orgId);
                break;
            case IMP_WAGA:
                // 水闸
                this.downloadTemplateWaga(response, userId, orgType, orgIds,datas,orgId);
                break;
            case IMP_EMPWT:
                // 水利工程建设
                this.downloadTemplateKeyReg(response, userId, orgType, orgIds,datas,orgId);
                break;
            case IMP_EMPWTRUN:
                // 水利工程运行
                this.downloadTemplateKeyReg(response, userId, orgType, orgIds,datas,orgId);
                break;
            case IMP_SD:
                // 淤地坝
                this.downloadTemplateSd(response, userId, orgIds, impPblmEnum,datas,orgId);
                break;
            case IMP_WIU:
                // 取水口
                this.downloadTemplateWiu(response, userId, orgIds, impPblmEnum,datas,orgId);
                break;
            case IMP_SWHS:
                // 水源地
                this.downloadTemplateSwhs(response, userId, orgIds, impPblmEnum,datas,orgId);
                break;
            case IMP_SVWT:
                // 节水管理与评价
                this.downloadTemplateSvwt(response, userId, orgIds, impPblmEnum, datas,orgId);
                break;
            case IMP_WUNT:
                // 用水单位抽查
                this.downloadTemplateWunt(response, userId, orgIds, impPblmEnum,datas,orgId);
                break;
            default:
                break;
        }
    }

    private Object getConverDatas(String datas,Object object){
        try {
            if(datas == null){
                return object;
            }
            return JSONObject.parseObject(datas, object.getClass());
        }catch (Exception e){
            e.printStackTrace();
        }
        return object;
    }

    public void downloadTemplateRever(HttpServletResponse response,String userId,String orgType,
                                      String orgIds,String datas,String orgId) throws Exception{

        ReverParam reverParam = (ReverParam)this.getConverDatas(datas,new ReverParam());
        reverParam.setOrgIds(InspUtils.setOrgIds(orgIds));
        reverParam.setPersId(userId);
        reverParam.setOrgId(orgId);
        List<BisInspPblm> pblmList=bisInspPblmDao.findReverPlbmList(reverParam);

        // 模板路径
        String filePath = templatePath + File.separator + "pblmSk.xls";
        // SHEET名称
        String sheetName = "水库问题";
        // 文件名称带后缀
        String fileName = sheetName + ".xls";
        // startRow
        int startRow = 2;

        // 使用通用的下载模板的方法
        List<Map<String, Object>> dataList = ExpAndImpUtil.convertBeanToList(pblmList, pblmFieldArrays, PblmFieldFormatExp.class);

        // 处理其他特殊字段
        for(BisInspPblm bisInspPblm : pblmList){
            // 处理图片路径
            List<GwComFile> bizFiles = gwComFileService.findFileByBiz(bisInspPblm.getPblmId());
            String[] filePaths = bizFiles.stream().filter(x -> x.getBizId() != null && x.getBizId().equals(bisInspPblm.getPblmId())).map(GwComFile::getFilePath).toArray(String[]::new);
            String filePathsStr = StringUtils.join(filePaths,";");
            // 处理groupName
             List<BisInspAll> list = impPblmDao.getGroupList(userId, bisInspPblm.getOid());
            for(Map<String,Object> map : dataList){
                if(bisInspPblm.getPblmId().equals(map.get("pblmId"))){
                    // 处理省市县
                    ExpUtil.getAdNames(map,bisInspPblm.getAdFullName());
                    // 问题标准附件
                    map.put("attachSheet",(bisInspPblm.getAttach() != null ? bisInspPblm.getAttach() : "")+"-"+(bisInspPblm.getSheet()!=null ? bisInspPblm.getSheet() : ""));
                    map.put("path", FieldFormat.formatCheckNull(filePathsStr));
                    // 处理RsCode
//                    BisInspRsvrRgstr bisInspRsvrRgstr = bisInspRsvrRgstrDao.get(bisInspPblm.getRegid());
//                    if(bisInspRsvrRgstr != null){
//                        map.put("rsCode",bisInspRsvrRgstr.getRsCode());
//                    }
                    map.put("rsCode",bisInspPblm.getCode());
                    if(list.size() > 0){
                         map.put("groupName",list.get(0).getPnm());
                    }
                    // insp_pblm_code 要取snNum
                    map.put("inspPblmCode",bisInspPblm.getSnNum());
                }
            }
        }
        // 获取一个已经填满数据的WorkBook
        Workbook workBook = ExpAndImpUtil.getWorkbook(dataList, filePath, startRow, sheetName);

        List<BisInspAll> list = impPblmDao.getGroupList(userId, orgType);
        String[] groupNames = list.stream().map(BisInspAll::getPnm).toArray(String[]::new);
        // 给组别加上一个下拉列表，组别字段在第5列，firstCol=5-1
        ExpAndImpUtil.createListBox(groupNames,3,4,workBook);
        // 获取水库名称列表 从登记表获取
        TypeParam typeParam = new TypeParam();
        typeParam.setPresId(userId);
        typeParam.setpType(IMP_REVER.getObjType());
        List<BisInspRsvrRgstrPcDto> bisInspRsvrRgstrPcDtoList = bisInspRsvrRgstrDao.findPcPage(typeParam);
        String[] rsNames = bisInspRsvrRgstrPcDtoList.stream().map(BisInspRsvrRgstrPcDto::getNm).distinct().toArray(String[]::new);
        // 给水库名称再加一个下拉列表，水库名称在第7列，firstCol=7-1
        ByteArrayOutputStream os = ExpAndImpUtil.createListBox(rsNames,3,6,workBook);
        // 下载
        ExpAndImpUtil.downloadExcelFile(response, os,fileName);
    }

    public void downloadTemplateSd(HttpServletResponse response,String userId,String orgIds,
                                   ImpPblmEnum impPblmEnum,String datas,String orgId) throws Exception{

        SdPblmParam sdPblmParam = (SdPblmParam)this.getConverDatas(datas,new SdPblmParam());
        sdPblmParam.setOrgIds(InspUtils.setOrgIds(orgIds));
        sdPblmParam.setPersId(userId);
        sdPblmParam.setOrgId(orgId);
        sdPblmParam.setpType(impPblmEnum.getObjType());
        List<BisInspPblm> pblmList=bisInspPblmDao.findSdPblmList(sdPblmParam);

        // 使用通用的业务下载方法
        this.downloadTemplateCommon(response,userId,impPblmEnum,pblmList);
    }

    public void downloadTemplateSwhs(HttpServletResponse response,String userId,String orgIds,
                                     ImpPblmEnum impPblmEnum,String datas,String orgId) throws Exception{

        PblmParam pblmParam = (PblmParam)this.getConverDatas(datas,new PblmParam());
        pblmParam.setOrgIds(InspUtils.setOrgIds(orgIds));
        pblmParam.setPersId(userId);
        pblmParam.setOrgId(orgId);
        pblmParam.setpType(impPblmEnum.getObjType());
        List<BisInspPblm> pblmList=bisInspPblmDao.findPblmList(pblmParam);

        // 使用通用的业务下载方法
        this.downloadTemplateCommon(response,userId,impPblmEnum,pblmList);
    }

    public void downloadTemplateWiu(HttpServletResponse response,String userId,String orgIds,
                                    ImpPblmEnum impPblmEnum,String datas,String orgId) throws Exception{
        this.downloadTemplateSwhs(response,userId,orgIds,impPblmEnum,datas,orgId);
    }

    public void downloadTemplateSvwt(HttpServletResponse response,String userId,String orgIds,
                                     ImpPblmEnum impPblmEnum,String datas,String orgId) throws Exception{
        this.downloadTemplateSwhs(response,userId,orgIds,impPblmEnum,datas,orgId);
    }

    public void downloadTemplateWunt(HttpServletResponse response,String userId,String orgIds,
                                     ImpPblmEnum impPblmEnum,String datas,String orgId) throws Exception{
        this.downloadTemplateSwhs(response,userId,orgIds,impPblmEnum,datas,orgId);
    }

    private void downloadTemplateCommon(HttpServletResponse response,String userId,ImpPblmEnum impPblmEnum,List<BisInspPblm> pblmList) throws Exception{

        // 模板路径
        String filePath = templatePath + File.separator + impPblmEnum.getFilePath();
        // SHEET名称
        String sheetName = impPblmEnum.getSheetName();
        // 文件名称带后缀
        String fileName = impPblmEnum.getFileName();
        // startRow
        int startRow = impPblmEnum.getStartRow();

        // 使用通用的下载模板的方法
        List<Map<String, Object>> dataList = ExpAndImpUtil.convertBeanToList(pblmList, pblmFieldArrays, PblmFieldFormatExp.class);
        // 处理其他特殊字段
        for(BisInspPblm bisInspPblm : pblmList){
            for(Map<String,Object> map : dataList){
                if(bisInspPblm.getPblmId().equals(map.get("pblmId"))){
                    // 处理省市县
                    ExpUtil.getAdNames(map,bisInspPblm.getAdFullName());
                    // 问题标准附件
                    map.put("attachSheet",this.formatAttachSheet(bisInspPblm.getAttach(),bisInspPblm.getSheet()));
                    // 处理图片路径
                    List<GwComFile> bizFiles = gwComFileService.findFileByBiz(bisInspPblm.getPblmId());
                    String[] filePaths = bizFiles.stream().map(GwComFile::getFilePath).toArray(String[]::new);
                    String filePathsStr = StringUtils.join(filePaths,";");
                    map.put("path", FieldFormat.formatCheckNull(filePathsStr));
                    // 处理groupName
                    String pType = bisInspPblm.getObjType();

                    List<BisInspAll> list = impPblmDao.getGroupLists(userId, bisInspPblm.getOid(),PtypeConversionUtil.completion(pType));
                    if(list.size() > 0){
                        map.put("groupName",list.get(0).getPnm());
                    }
                    // insp_pblm_code 如果没有 去取snNum
                    if(StringUtils.isBlank(bisInspPblm.getInspPblmCode())){
                        map.put("inspPblmCode",bisInspPblm.getSnNum());
                    }
                }
            }
        }
        // 获取一个已经填满数据的WorkBook
        Workbook workBook = ExpAndImpUtil.getWorkbook(dataList, filePath, startRow, sheetName);

        List<BisInspAll> list = impPblmDao.getGroupLists(userId, impPblmEnum.getOrgType(),PtypeConversionUtil.completion(impPblmEnum.getObjType()));
        String[] groupNamesList = list.stream().map(BisInspAll::getPnm).toArray(String[]::new);
        // 给组别加上一个下拉列表，组别字段在第5列，firstCol=5-1
        ByteArrayOutputStream os = ExpAndImpUtil.createListBox(groupNamesList,3,4,workBook);

        // 下载
        ExpAndImpUtil.downloadExcelFile(response, os,fileName);

    }


    public void downloadTemplateWaga(HttpServletResponse response,String userId,String orgType,
                                     String orgIds,String datas,String orgId) throws Exception{

        WagaParam wagaParam = (WagaParam)this.getConverDatas(datas,new WagaParam());
        wagaParam.setOrgIds(InspUtils.setOrgIds(orgIds));
        wagaParam.setPersId(userId);
        wagaParam.setOrgId(orgId);
        List<BisInspPblm> pblmList=bisInspPblmDao.findWagaPlbmList(wagaParam);

        // 模板路径
        String filePath = templatePath + File.separator + "pblmSz.xls";
        // SHEET名称
        String sheetName = "水闸问题";
        // 文件名称带后缀
        String fileName = sheetName + ".xls";
        // startRow
        int startRow = 2;

        // 使用通用的下载模板的方法
        List<Map<String, Object>> dataList = ExpAndImpUtil.convertBeanToList(pblmList, pblmFieldArrays, PblmFieldFormatExp.class);
        // 处理其他特殊字段
        for(BisInspPblm bisInspPblm : pblmList){
            // 处理图片路径
            List<GwComFile> bizFiles = gwComFileService.findFileByBiz(bisInspPblm.getPblmId());
            String[] filePaths = bizFiles.stream().map(GwComFile::getFilePath).toArray(String[]::new);
            String filePathsStr = StringUtils.join(filePaths,";");
            // 处理groupName
            List<BisInspAll> list = impPblmDao.getGroupList(userId, bisInspPblm.getOid());
            for(Map<String,Object> map : dataList){
                if(bisInspPblm.getPblmId().equals(map.get("pblmId"))){
                    // 处理省市县
                    ExpUtil.getAdNames(map,bisInspPblm.getAdFullName());
                    // 问题标准附件
                    map.put("attachSheet",(bisInspPblm.getAttach() != null ? bisInspPblm.getAttach() : "")+"-"+(bisInspPblm.getSheet()!=null ? bisInspPblm.getSheet() : ""));
                    map.put("path", FieldFormat.formatCheckNull(filePathsStr));
                    // 处理objCode 水闸编码
//                    AttWagaRgstr attWagaRgstr = attWagaRgstrDao.get(bisInspPblm.getRegid());
//                    if(attWagaRgstr != null){
//                        map.put("objCode",attWagaRgstr.getObjCode());
//                        map.put("gateName",attWagaRgstr.getGateName());
//                    }
                    map.put("objCode",bisInspPblm.getCode());
                    map.put("gateName",bisInspPblm.getNm());
                    if(list.size() > 0){
                        map.put("groupName",list.get(0).getPnm());
                    }
                    // insp_pblm_code 要取snNum
                    map.put("inspPblmCode",bisInspPblm.getSnNum());
                }
            }
        }

        Workbook workBook = ExpAndImpUtil.getWorkbook(dataList, filePath, startRow, sheetName);

        List<BisInspAll> list = impPblmDao.getGroupList(userId, orgType);
        String[] groupNamesList = list.stream().map(BisInspAll::getPnm).toArray(String[]::new);
        // 组别字段在第5列，firstCol=5-1
        ExpAndImpUtil.createListBox(groupNamesList,3,4,workBook);

        // 获取水闸名称列表 从登记表里获取
        TypeParam typeParam = new TypeParam();
        typeParam.setPresId(userId);
        typeParam.setpType(IMP_WAGA.getObjType());
        List<BisInspWagaRgstrDto> bisInspWagaRgstrDtoList = attWagaRgstrDao.findWagaPage(typeParam);
        String[] gateNames = bisInspWagaRgstrDtoList.stream().map(BisInspWagaRgstrDto::getNm).distinct().toArray(String[]::new);
        // 给水闸名称再加一个下拉列表，水闸名称在第7列，firstCol=7-1
        ByteArrayOutputStream os = ExpAndImpUtil.createListBox(gateNames,3,6,workBook);
        ExpAndImpUtil.downloadExcelFile(response, os,fileName);
    }

    public void downloadTemplateKeyReg(HttpServletResponse response,String userId,
                                       String orgType,String orgIds,String datas,String orgId) throws Exception{
        ImpPblmEnum impPblmEnum = ImpPblmEnum.getEnumByOrgType(orgType);
        // 督查类型 4水利工程建设 7水利工程运行
        if(impPblmEnum == null){
            return;
        }
        KeyRegPatam keyRegPatam = (KeyRegPatam)this.getConverDatas(datas,new KeyRegPatam());
        keyRegPatam.setOrgIds(InspUtils.setOrgIds(orgIds));
        keyRegPatam.setPersId(userId);
        keyRegPatam.setOrgId(orgId);
        keyRegPatam.setpType(impPblmEnum.getObjType());
        // 如果是建设
        if(impPblmEnum == IMP_EMPWT) {
            // 复查结论
            keyRegPatam.setReviConc("0");
        }
        List<KeyRegPblm> pblmList=bisInspPblmDao.findKeyRegPlbmList(keyRegPatam);
        // 模板文件路径
        String filePath = templatePath + File.separator + impPblmEnum.getFilePath();
        // 开始行
        int startRow = 2;

        // 使用通用的下载模板的方法
        List<Map<String, Object>> dataList = ExpAndImpUtil.convertBeanToList(pblmList, pblmFieldArrays, PblmFieldFormatExp.class);
        // 处理其他特殊字段
        for(KeyRegPblm bisInspPblm : pblmList){
            for(Map<String,Object> map : dataList){
                if(bisInspPblm.getPblmId().equals(map.get("pblmId"))){
                    // 处理省市县
                    ExpUtil.getAdNames(map,bisInspPblm.getAdFullName());
                    // 处理图片路径
                    List<GwComFile> bizFiles = gwComFileService.findFileByBiz(bisInspPblm.getPblmId());
                    String[] filePaths = bizFiles.stream().map(GwComFile::getFilePath).toArray(String[]::new);
                    String filePathsStr = StringUtils.join(filePaths,";");
                    map.put("path", FieldFormat.formatCheckNull(filePathsStr));
                    // 处理groupName
                    List<BisInspAll> list = impPblmDao.getGroupList(userId, bisInspPblm.getOid());
                    if(list.size() > 0){
                        map.put("groupName",list.get(0).getPnm());
                    }
                    // 处理单位名称
                    List<String> dwNmList = impPblmDao.getNmByRegId(bisInspPblm.getRegid(),orgType);
                    if(dwNmList.size() > 0){
                        map.put("dwNm", dwNmList.get(0));
                    }else {
                        map.put("dwNm", "");
                    }
                    try {
                        if("004".equals(orgType)){
                            // 处理标段名称
                            BisInspKeyRegisterSection bisInspKeyRegisterSection = bisInspKeyRegisterSectionDao.findSecByUnitId(bisInspPblm.getRegid());
                            if(bisInspKeyRegisterSection != null){
                                map.put("bdNm", bisInspKeyRegisterSection.getNm());
                            }else {
                                map.put("bdNm", "");
                            }
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    // 处理attachWg
                    if(bisInspPblm.getAttachWg() != null && bisInspPblm.getAttachWg().endsWith("-")){
                        map.put("attachWg",bisInspPblm.getAttachWg().replace("-",""));
                    }
                    // 处理attachDef
                    if(bisInspPblm.getAttachDef() != null && bisInspPblm.getAttachDef().endsWith("-")){
                        map.put("attachDef",bisInspPblm.getAttachDef().replace("-",""));
                    }
                }
            }
        }
        Workbook workBook = ExpAndImpUtil.getWorkbook(dataList, filePath, startRow, impPblmEnum.getSheetName());
        List<BisInspAll> list = impPblmDao.getGroupList(userId, orgType);
        String[] groupNamesList = list.stream().map(BisInspAll::getPnm).toArray(String[]::new);
        // 组别字段在第5列，firstCol=5-1
        ByteArrayOutputStream os = ExpAndImpUtil.createListBox(groupNamesList,3,4,workBook);
        ExpAndImpUtil.downloadExcelFile(response, os,impPblmEnum.getFileName());
    }

    private String formatAttachSheet(String attach,String sheet){
        if(StringUtils.isBlank(attach)){
            return "";
        }else if(StringUtils.isBlank(sheet)){
            return attach;
        }else{
            return attach + "-" + sheet;
        }
    }
    private String formatAttachSheet(String value){
        if(StringUtils.isBlank(value)){
            return "";
        }else if(value.endsWith("-")){
            return value.replace("-","");
        }else{
            return value;
        }
    }



    @Override
    public String uploadFile(MultipartFile[] files) {

//        return this.uploadFileSingle(files);
        return this.uploadFileMore(files);
    }

    public String uploadFileMore(MultipartFile[] files){
        if(files.length > 0){
            String info = "";
            for (MultipartFile file : files){
                // 如果上传成功
                switch (file.getOriginalFilename().split("\\.")[1]){
                    case ImpUtil.XLS:
//                        info = this.uploadFileExcel(file);
                        info = this.uploadFileExcelCommon(file);
                        break;
                    case ImpUtil.ZIP:
//                        info = this.uploadFileZip(file);
                        info = this.uploadFileZipCommon(file);
                        break;
                    default:
                        info = "文件类型不对";
                        break;
                }
            }
            return info;
        }else {
            return "文件为空";
        }

    }

    public String uploadFileSingle(MultipartFile file) {
            String info = "";
            // 如果上传成功
            switch (file.getOriginalFilename().split("\\.")[1]){
                case ImpUtil.XLS:
                    info = this.uploadFileExcel(file);
                    break;
                case ImpUtil.ZIP:
                    info = this.uploadFileZip(file);
                    break;
                default:
                    info = "文件类型不对";
                    break;
            }
            return info;

    }

    @Override
    public Map<String,Object> parseTemplate(String filePath,String userId,String orgType) {
        Map<String,Object> map = new HashMap<>();
        List<LinkedHashMap<String,Object>> listParse = null;
        int startRow = 2;
        int endRow = 0;
        List<LinkedHashMap<String, Object>> listShow = new ArrayList<>();
        try {
            // 获取到从Excel里提取到的数据，并已格式化
            listParse = ImportExcel.getParseData(filePath,startRow,endRow, PblmFieldFormatImp.class);

            if(listParse.size() > 0){
                String cacheId = UuidUtil.uuid();
                redisTemplate.opsForList().rightPushAll(cacheId,listParse);
                map.put("cacheId",cacheId);
            }else{
                map.put("cacheId","");
            }

            // 添加警告,（先不放开）
            if(listParse.size() > 0){
//                if(listParse.get(0).get("rsCode") != null){
//                    checkHasObjPblm(listParse,userId,"001");
//                }else if(listParse.get(0).get("objCode") != null){
//                    checkHasObjPblm(listParse,userId,"006");
//                }
                checkHasObjPblm(listParse,userId,orgType);
            }

            listShow = ImportExcel.getShowData(listParse, PblmFieldFormatExp.class);

            map.put("listParse",listShow);



        } catch (IOException e) {
            e.printStackTrace();
        }
        return map;
    }

    @Override
    public boolean insertTemplate(String cacheId,String userId,String updateState,String orgType) {
        return this.insertTemplateState(cacheId,userId,updateState,orgType);
    }

    public boolean insertTemplateState(String cacheId,String userId,String updateState,String orgType) {
        // 从redis里获取到数据
        List<LinkedHashMap<String, Object>> listParse = this.getParseDataByRedis(cacheId);
        // 去重复pblmId处理，可能增加问题时会直接复制了上一行数据会把pblmId带上，预防一下，取第一条，剩余pblmId置空
        ExpAndImpUtil.handleRepeatPrimaryKey(listParse,"pblmId");

        // 取出来的数据，分为两种情况，一种是有pblmId的，一种是没有的
        // 如果有
        List<LinkedHashMap<String, Object>> hasPblmIdList = listParse.stream().filter(x -> StringUtils.isNotBlank(MapUtils.getString(x,"pblmId"))).collect(Collectors.toList());
        // 如果无
        List<LinkedHashMap<String, Object>> notHasPblmIdList = listParse.stream().filter(x -> StringUtils.isBlank(MapUtils.getString(x,"pblmId"))).collect(Collectors.toList());
        // 批量插入
        boolean hasSuccess = true;
        boolean notHasSuccess = true;
        // 有pblmId，则更新
        this.updateSuccessCount = 0;
        if(hasPblmIdList.size() > 0){
            hasSuccess = this.batchUpdate(hasPblmIdList,userId,updateState,orgType);
        }else {
            hasSuccess = false;
        }
        // 无pblmId，则添
        this.insertSuccessCount = 0;
        if(notHasPblmIdList.size() > 0){
            notHasSuccess = this.batchInsert(notHasPblmIdList,userId,updateState,orgType);
        }else {
            notHasSuccess = false;
        }

        if(hasSuccess && notHasSuccess){
//            return "插入成功！";
            return true;
        }else {
//            return "插入失败！";
            return false;
        }
    }

    @Override
    public String insertTemplateInfo(String cacheId,String userId,String updateState,String orgType) {
        // 从redis里获取到数据
        List<LinkedHashMap<String, Object>> listParse = this.getParseDataByRedis(cacheId);
        // 去重复pblmId处理，可能增加问题时会直接复制了上一行数据会把pblmId带上，预防一下，取第一条，剩余pblmId置空
        ExpAndImpUtil.handleRepeatPrimaryKey(listParse,"pblmId");

        // 取出来的数据，分为两种情况，一种是有pblmId的，一种是没有的
        // 如果有
        List<LinkedHashMap<String, Object>> hasPblmIdList = listParse.stream().filter(x -> StringUtils.isNotBlank(MapUtils.getString(x,"pblmId"))).collect(Collectors.toList());
        // 如果无
        List<LinkedHashMap<String, Object>> notHasPblmIdList = listParse.stream().filter(x -> StringUtils.isBlank(MapUtils.getString(x,"pblmId"))).collect(Collectors.toList());
        // 批量插入
        // 有pblmId，则更新
        this.updateSuccessCount = 0;
        if(hasPblmIdList.size() > 0){
            this.batchUpdate(hasPblmIdList,userId,updateState,orgType);
        }
        // 无pblmId，则添加
        this.insertSuccessCount = 0;
        if(notHasPblmIdList.size() > 0){
            this.batchInsert(notHasPblmIdList,userId,updateState,orgType);
        }

        // 总数
        int sumCount = listParse.size();
        // 更新
        int updateCount = hasPblmIdList.size();
        // 新增
        int insertCount = notHasPblmIdList.size();


        return  " 此次填报共：<b>" + sumCount + "</b>条,其中库里<i>原有数据</i>：<b>" + updateCount + "</b>条，<i>新增数据</i>：<b>" + insertCount + "</b>条。" +
                "<p><b>" + updateCount + "</b>条<i>原有数据</i>：修改成功<b>" + this.updateSuccessCount + "</b>条，失败<b>"+ (updateCount - this.updateSuccessCount) + "</b>条</p>" +
                "<p><b>" + insertCount + "</b>条<i>新增数据</i>：添加成功<b>" + this.insertSuccessCount + "</b>条，失败<b>"+ (insertCount - this.insertSuccessCount) + "</b>条</p>";


    }

    /**
     * 真正执行入库操作的方法(更新)
     * @see cn.com.goldenwater.dcproj.controller.pblm.BisInspPblmController#insert(BisInspPblm)
     */
    private boolean batchUpdate(List<LinkedHashMap<String, Object>> listParse,String userId,String updateState,String orgType){
        boolean success = false;
        this.updateSuccessCount = 0;

        List<BisInspPblm> list = new ArrayList<>();
//        List<GwComFile> listGwComFile = new ArrayList<>();
        // 把list<map> 转为 list<bean>
        for(LinkedHashMap<String,Object> lhp : listParse){
            try{
                BisInspPblm bisInspPblm = (BisInspPblm) convertMapToBean(BisInspPblm.class, lhp);
                // 如果这里为NULL,就不用继续了，肯定失败
                if(bisInspPblm == null){
                    continue;
                }
                // 设置问题字段
                boolean setColumnState = this.setColumn(bisInspPblm,lhp,userId,orgType);
                if(!setColumnState){
                    continue;
                }
                // 这里更新的时候暂时不更新多媒体，不确定会不会更改多媒体
                // 设置文件字段
                // this.setFileColumn(bisInspPblm,lhp,listGwComFile);

                // 添加进问题List
                list.add(bisInspPblm);

            }catch (Exception e){
                e.printStackTrace();
            }
        }

        // 用mybatis执行批量插入，提高效率
        try {
            if(list.size() > 0){
                // 最后再检查一下字段里是否有错误标识,检查无误，问题入库
                if(!list.toString().contains(ERR)){
                    // 更新问题表，出于安全考虑，没有选择SQL批量更新，
                    for(BisInspPblm bisInspPblm : list){
                        bisInspPblmDao.update(bisInspPblm);
                    }
                    success = true;
                    // 成功计数
                    this.updateSuccessCount = list.size();
                }
            }else {
                this.updateSuccessCount = 0;
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return success;

    }

    /**
     * 真正执行入库操作的方法
     * @see cn.com.goldenwater.dcproj.controller.pblm.BisInspPblmController#insert(BisInspPblm)
     */
    private boolean batchInsert(List<LinkedHashMap<String, Object>> listParse,String userId,String updateState,String orgType){
        boolean success = false;
        this.insertSuccessCount = 0;

        List<BisInspPblm> list = new ArrayList<>();
        List<GwComFile> listGwComFile = new ArrayList<>();
        // 把list<map> 转为 list<bean>
        for(LinkedHashMap<String,Object> lhp : listParse){
            try{
                BisInspPblm bisInspPblm = (BisInspPblm) convertMapToBean(BisInspPblm.class, lhp);
                // 如果这里为NULL,就不用继续了，肯定失败
                if(bisInspPblm == null){
                    continue;
                }
                // 设置问题字段
                boolean setColumnState = this.setColumn(bisInspPblm,lhp,userId,orgType);
                if(!setColumnState){
                    continue;
                }
                // 设置文件字段
                this.setFileColumn(bisInspPblm,lhp,listGwComFile);

                // 添加进问题List
                list.add(bisInspPblm);

            }catch (Exception e){
                e.printStackTrace();
            }
        }

        // 用mybatis执行批量插入，提高效率
        try {
            if(list.size() > 0){
                // 最后再检查一下字段里是否有错误标识,检查无误，问题入库
                if(!list.toString().contains(ERR)){
                    // 判断是否需要覆盖新增，如果是，先把原来的清掉
                    if("0".equals(updateState)){
                        for(BisInspPblm pblm : list){
                            // 先删文件
                            // 按bizId一个一个删，一下子删怕错删数据
                            String bizId = pblm.getPblmId();
                            List<GwComFile> gwComFileList = gwComFileService.findFileByBiz(bizId);
                            // 不用deleteBy 太危险
                            for(int i=0;i<gwComFileList.size();i++){
                                String id = gwComFileList.get(i).getId();
                                gwComFileService.delete(id);
                            }

                            // 再删问题
                            BisInspPblmParam pblmParam = new BisInspPblmParam();
                            pblmParam.setObjId(pblm.getObjId());
                            List<BisInspPblm> pblmList = bisInspPblmService.findList(pblmParam);
                            for(int i=0;i<pblmList.size();i++){
                                String pblmId = pblmList.get(i).getPblmId();
                                bisInspPblmService.delete(pblmId);
                            }
                        }
                    }
                    if(list.size()>0){
                        impPblmDao.batchInsert(list);
                    }
                    // 问题多媒体文件入库
                    if(listGwComFile.size() > 0){
                        impPblmDao.batchInsertGwFile(listGwComFile);
                    }

                    success = true;

                    // 成功计数
                    this.insertSuccessCount = list.size();
                }
            }else {
                this.insertSuccessCount = 0;
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return success;

    }

    private void setFileColumn(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,List<GwComFile> listGwComFile){
        // 有图片
        Object path = lhp.get("path");
        if(path != null && !"".equals(path)){
            String pathStr = path.toString().replace("；",";");
            String[] pathStrArr = pathStr.split(";");

            String isHasVideo = "0";
            // 没有分号时length为1
            if(pathStrArr.length > 0){
                for(String pathStrItem : pathStrArr){
                    GwComFile gwComFile = this.setFileColumnSingle(pathStrItem,bisInspPblm);
                    if(StringUtils.isNotBlank(gwComFile.getFilePath())){
                        listGwComFile.add(gwComFile);
                        isHasVideo = "1";
                    }
                }
            }
            // 应该根据path里的值来决定是否有多媒体，所以暂时把下面这段逻辑注释掉
//            if(StringUtils.isNotBlank(MapUtils.getString(lhp,"hasVedio"))){
//                isHasVideo = MapUtils.getString(lhp,"hasVedio");
//            }
            bisInspPblm.setHasVedio(isHasVideo);
        }else {
            bisInspPblm.setHasVedio("0");
        }
    }

    private GwComFile setFileColumnSingle(String pathStr,BisInspPblm bisInspPblm){
        // pathStr  /lyz/test.png
        GwComFile gwComFile = new GwComFile();
        String gwId = UuidUtil.uuid();
        gwComFile.setId(gwId);
        gwComFile.setBizId(bisInspPblm.getPblmId());
        // 去除前面和后面的空格，不然文件类型会识别不了
        pathStr = pathStr.trim();
        if(pathStr.contains("\\")){
            pathStr = pathStr.replace("\\","/");
        }
        // 设置其他字段
        String[] fileTitles = pathStr.split("/");
        if(fileTitles.length > 0){
            String fileTitle = fileTitles[fileTitles.length-1];
            // 设置文件名称和title
            gwComFile.setFileTitle(fileTitle);
            gwComFile.setFileName(fileTitle);
            // 设置扩展名
            String[] fileExts = fileTitle.split("\\.");
            if(fileExts.length > 0){
                gwComFile.setFileExt(fileExts[fileExts.length-1]);
            }
        }

        // 设置path字段
        String[] pathStrArr = pathStr.split(":");
        // 有:说明带盘符 length为2，无:分割说明不带盘符 length为1
        if(pathStrArr.length > 0){
            try{
                this.setColumnFilePath(gwComFile,pathStrArr,pathStr,gwId);
            }catch (Exception e){
                e.printStackTrace();
            }
        }

        return gwComFile;
    }

    /**
     * 设置文件路径
     *
     * @param gwComFile 文件实体类
     * @param pathStrArr  从模板里获取的路径以：分割之后的数组 ["D","/lyz/test.png"] 或者 ["/lyz/test.png"] 或者 ["/lyz/test"]
     * @param pathStr 从模板里获取的路径 /lyz/test.png
     * @param gwId 文件id
     */
    private void setColumnFilePath(GwComFile gwComFile,String[] pathStrArr,String pathStr,String gwId){
        // 图片临时路径 /DC/upload/2019/7/20/lyz/图片.jpg 从模板里获取
        String pathStrItemSave = getDateFormatPath(this.impExcelBashPath) + File.separator + pathStrArr[pathStrArr.length-1];

        // 对从模板里获取的图片路径进行处理
         pathStrItemSave = this.checkIsExistImg(gwComFile,pathStrItemSave.replace("\\","/"));

        // 图片的后缀
        String suffixPath =  File.separator + gwId + pathStrItemSave.substring(pathStrItemSave.lastIndexOf("."));
        // 图片存储的表里存的路径，入库用 /upload/
        String pathStrTableSave = getDateFormatPath(this.imgPathPrefix) + suffixPath;
        // 图片存储的真正路径
        String pathStrDiskSave = getDateFormatPath(this.imgPath) + suffixPath;
        // 判断临时路径处有 没有这张图片，有的话复制到图片文件夹下
        File file = new File(pathStrItemSave);
        if(file.exists()){
            try {
                FileUtils.copyFile(file,new File(pathStrDiskSave));
                gwComFile.setFilePath(pathStrTableSave);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private String checkIsExistImg(GwComFile gwComFile, String pathStrItemSave) {

        // 解析获取的图片路径，判断用户到底上传了这张图片没有
        // 1.有后缀名，且大小写正确
        // 2.无后缀名
        // 3.有后缀名，大小写不正确

        try{

            // 模板里的图片的名称 test.png | test
            String imgName = pathStrItemSave.split("/")[pathStrItemSave.split("/").length-1];
            // .png .jpg .jpeg gif
            if(imgName.contains(".")){
                // test
                imgName = imgName.substring(0,imgName.lastIndexOf("."));
            }

            // D:\lyz
            String folderPath = pathStrItemSave.substring(0,pathStrItemSave.lastIndexOf("/"));
            File folder = new File(folderPath);
            File[] fileList = folder.listFiles();
            if(fileList != null){
                for(File f : fileList){
                    String fileName = f.getName();
                    if(fileName.contains(imgName)){
                        boolean isExist = false;
                        String ext1 = fileName.substring(fileName.lastIndexOf(".")+1);
                        // 如果有后缀名
                        if(pathStrItemSave.contains(".")){
                            String ext2 = pathStrItemSave.substring(pathStrItemSave.lastIndexOf(".")+1);
                            if(ext1.toUpperCase().equals(ext2.toUpperCase())){
                                isExist = true;
                            }
                        }else{
                            isExist = true;
                        }
                        if(isExist){
                            // D:\lyz\test.png
                            pathStrItemSave = folderPath + File.separator + fileName;
                            // test.png
                            gwComFile.setFileTitle(fileName);
                            // .png
                            gwComFile.setFileExt(ext1);
                        }

                    }
                }
            }

        }catch (Exception e){
            e.printStackTrace();
        }

        return pathStrItemSave;
    }

    private boolean setColumn(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,String orgType){
        int count = 0;
        if(!this.setColumnOfRequired(bisInspPblm,lhp,userId,orgType)){
            count ++;
        }
        if(!this.setColumnOfSpecial(bisInspPblm,lhp,userId,orgType)){
            count ++;
        }
        if(!this.setColumnOfOther(bisInspPblm,lhp,userId,orgType)){
            count ++;
        }
        if(count > 0){
            return false;
        }else {
            return true;
        }

    }

    private boolean setColumnOfRequiredRever(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        // 必要字段 1）：督查问题ID 。
        if(StringUtils.isBlank(bisInspPblm.getPblmId())){
            // 如果导进来的不带pblmId,给赋值
            bisInspPblm.setPblmId(UuidUtil.uuid());
        }

        // 必要字段2）：名录ID  获取方式 根据1组别，2用户id，3督查类型，4水库编码 确定唯一objId和rgstrId
        // 4 水库编码 改成使用名称
//        Object rsCode = lhp.get("rsCode");
        Object rsCode = lhp.get("rsName");
        if(rsCode == null){
            return false;
        }
        // 1 组别
        Object groupName = lhp.get("groupName");
        if(groupName == null){
            return false;
        }
        String id = this.getGroupIdByName(groupName.toString(),userId,impPblmEnum.getOrgType());
        if(StringUtils.isBlank(id)){
            return false;
        }
        // 获取名录ID 和 对应的objId,rgstrId
        BisInspRsvrRgstrPcDto pcDto = this.getRsvrRgstrDto(userId, impPblmEnum.getObjType(), rsCode.toString(),id);
        if(pcDto == null){
            return false;
        }
        // 设置ObjId,关键性字段
        bisInspPblm.setObjId(pcDto.getObjId());
        if(bisInspPblm.getObjId() == null){
            return false;
        }
        // 字段 25）：REGID  根据类型 来判断 是 1 小水库，2 农饮 3 水毁 4重点工程--登记ID
        bisInspPblm.setRegid(pcDto.getRgstrId());

        return true;
    }
    private boolean setColumnOfRequiredWaga(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        // 必要字段 1）：督查问题ID
        if(StringUtils.isBlank(bisInspPblm.getPblmId())){
            bisInspPblm.setPblmId(UuidUtil.uuid());
        }

        // 必要字段2）：名录ID  获取方式 根据1组别，2用户id，3督查类型，4水库编码 确定唯一objId和rgstrId
        // 4 水闸编码 改用水闸名称
//        Object objCode = lhp.get("objCode");
        Object objCode = lhp.get("gateName");
        if(objCode == null){
            return false;
        }
        // 1 组别
        Object groupName = lhp.get("groupName");
        if(groupName == null){
            return false;
        }
        String id = this.getGroupIdByName(groupName.toString(),userId,impPblmEnum.getOrgType());
        if(StringUtils.isBlank(id)){
            return false;
        }
        // 获取名录ID 和 对应的objId,rgstrId
        BisInspWagaRgstrDto pcDto = this.getWagaRgstrDto(userId, impPblmEnum.getObjType(), objCode.toString(),id);
        if(pcDto == null){
            return false;
        }
        // 设置ObjId,关键性字段
        bisInspPblm.setObjId(pcDto.getObjId());
        if(bisInspPblm.getObjId() == null){
            return false;
        }
        // 字段 25）：REGID  根据类型 来判断 是 1 小水库，2 农饮 3 水毁 4重点工程--登记ID
        bisInspPblm.setRegid(pcDto.getRgstrId());

        return true;
    }
    private boolean setColumnOfRequiredByJs(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        // 通过上传模板里的工程名称和单位名称和标段名称来获取对应的obj_id 和 reg_id
        ImpPblmKeyReg keyReg = new ImpPblmKeyReg();
        keyReg.setGcNm(MapUtils.getString(lhp,"nm"));
        keyReg.setDwNm(MapUtils.getString(lhp,"dwNm"));
        keyReg.setBdNm(MapUtils.getString(lhp,"bdNm"));
        keyReg.setObjType(impPblmEnum.getObjType());
        // 先设置一下组id
        String groupId = this.getGroupIdByName(MapUtils.getString(lhp,"groupName"),userId,impPblmEnum.getOrgType());
        keyReg.setGroupId(groupId);
        return this.setColumnOfRequiredByKeyReg(bisInspPblm,keyReg);
    }
    private boolean setColumnOfRequiredByYx(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        // 通过上传模板里的工程名称和单位名称来获取对应的obj_id 和 reg_id
        ImpPblmKeyReg keyReg = new ImpPblmKeyReg();
        keyReg.setDwNm(MapUtils.getString(lhp,"dwNm"));
        keyReg.setGcNm(MapUtils.getString(lhp,"nm"));
        keyReg.setObjType(impPblmEnum.getObjType());
        // 先设置一下组id
        String groupId = this.getGroupIdByName(MapUtils.getString(lhp,"groupName"),userId,impPblmEnum.getOrgType());
        keyReg.setGroupId(groupId);
        return this.setColumnOfRequiredByKeyReg(bisInspPblm,keyReg);
    }

    private boolean setColumnOfRequiredByKeyReg(BisInspPblm bisInspPblm,ImpPblmKeyReg keyReg){
        // [必要字段] 1）：督查问题ID
        if(StringUtils.isBlank(bisInspPblm.getPblmId())){
            bisInspPblm.setPblmId(UuidUtil.uuid());
        }
        // [必要字段] 2）名录ID和 3）登记表ID
        List<ImpPblmKeyReg> keyRegList = impPblmDao.getImpKeyRegList(keyReg);
        if(keyRegList == null || keyRegList.size() != 1){
            return false;
        }else {
            String objId = keyRegList.get(0).getObjId();
            String regId = keyRegList.get(0).getRegId();
            if(StringUtils.isBlank(objId)){
                return false;
            }else {
                bisInspPblm.setObjId(objId);
            }
            if(StringUtils.isBlank(regId)){
                return false;
            }else {
                bisInspPblm.setRegid(regId);
            }
        }
        return true;
    }

    private boolean setColumnOfRequiredBySd(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        // 必要字段 1）：督查问题ID 。
        if(StringUtils.isBlank(bisInspPblm.getPblmId())){
            // 如果导进来的不带pblmId,给赋值
            bisInspPblm.setPblmId(UuidUtil.uuid());
        }
        // 必要字段2）：名录ID  获取方式 根据1组别，2用户id，3督查类型，4水库编码 确定唯一objId和rgstrId
        String code = MapUtils.getString(lhp,"code");
        if(code == null){
            return false;
        }
        // 1 组别
        String groupName = MapUtils.getString(lhp,"groupName");
        if(groupName == null){
            return false;
        }
        List<BisInspAll> ids = this.getGroupIdByNameList(groupName, userId, impPblmEnum.getOrgType());
        BisInspSdRgstrDto pcDto = null;
        for(BisInspAll bisInspAll : ids){
            BisInspSdRgstrDto pcDtoItem = this.getSdRgstrDto(userId, impPblmEnum.getObjType(), code, bisInspAll.getId());
            if(pcDtoItem != null){
                pcDto = pcDtoItem;
                break;
            }
        }
        // 获取名录ID 和 对应的objId,rgstrId
        if(pcDto == null){
            return false;
        }
        // 设置ObjId,关键性字段
        bisInspPblm.setObjId(pcDto.getObjId());
        if(StringUtils.isBlank(bisInspPblm.getObjId())){
            return false;
        }
        // 字段 25）：REGID  根据类型 来判断 是 1 小水库，2 农饮 3 水毁 4重点工程--登记ID
        bisInspPblm.setRegid(pcDto.getId());
        if(StringUtils.isBlank(bisInspPblm.getRegid())){
            return false;
        }

        return true;
    }
    
    private boolean setColumnOfRequiredBySwhs(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        // 必要字段 1）：督查问题ID 。
        if(StringUtils.isBlank(bisInspPblm.getPblmId())){
            // 如果导进来的不带pblmId,给赋值
            bisInspPblm.setPblmId(UuidUtil.uuid());
        }
        // 必要字段2）：名录ID  获取方式 根据1组别，2用户id，3督查类型，4水库编码 确定唯一objId和rgstrId
        String code = MapUtils.getString(lhp,"code");
        if(code == null){
            return false;
        }
        // 1 组别
        String groupName = MapUtils.getString(lhp,"groupName");
        if(groupName == null){
            return false;
        }
        List<BisInspAll> ids = this.getGroupIdByNameList(groupName, userId, impPblmEnum.getOrgType());
        // 通用登记表
        BisInspRgstrDto pcDto = null;
        for(BisInspAll bisInspAll : ids){
            BisInspRgstrDto pcDtoItem = this.getRgstrCommon(userId, impPblmEnum.getObjType(), code, bisInspAll.getId());
            if(pcDtoItem != null){
                pcDto = pcDtoItem;
                break;
            }
        }
        // 获取名录ID 和 对应的objId,rgstrId
        if(pcDto == null){
            return false;
        }
        // 设置ObjId,关键性字段
        bisInspPblm.setObjId(pcDto.getObjId());
        if(StringUtils.isBlank(bisInspPblm.getObjId())){
            return false;
        }
        // 字段 25）：REGID  根据类型 来判断 是 1 小水库，2 农饮 3 水毁 4重点工程--登记ID
        bisInspPblm.setRegid(pcDto.getId());
        if(StringUtils.isBlank(bisInspPblm.getRegid())){
            return false;
        }

        return true;
    }
    private boolean setColumnOfRequiredByWiu(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        return this.setColumnOfRequiredBySwhs(bisInspPblm,lhp,userId,impPblmEnum);
    }

    private boolean setColumnOfRequiredBySvwt(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){

        // 必要字段1）督查问题主键ID
        if(StringUtils.isBlank(bisInspPblm.getPblmId())){
            // 如果导进来的不带pblmId,给赋值
            bisInspPblm.setPblmId(UuidUtil.uuid());
        }

        // 必要字段2）3）根据 1组别，2用户id，3督查类型  确定唯一objId和rgstrId
        String nm = MapUtils.getString(lhp,"nm");
        if(StringUtils.isBlank(nm)){
            return false;
        }

        // 组别
        String groupName = MapUtils.getString(lhp,"groupName");
        if(StringUtils.isBlank(groupName)){
            return false;
        }
        List<BisInspAll> groupIds = this.getGroupIdByNameList(groupName, userId, impPblmEnum.getOrgType());

        // 通用登记表
        BisInspRgstrDto pcDto = null;
        // 可能获取到多个组的唯一id
        for(BisInspAll bisInspAll : groupIds){
            BisInspRgstrDto pcDtoItem = this.getRgstrCommon(userId, impPblmEnum.getObjType(), nm, bisInspAll.getId());
            // 获得第一个不为Null的对象
            if(pcDtoItem != null){
                pcDto = pcDtoItem;
                break;
            }
        }

        // 获取对应的objId和rgstrId(regid)
        if(pcDto == null){
            return false;
        }

        // 设置ObjId 关键性字段
        bisInspPblm.setObjId(pcDto.getObjId());
        if(StringUtils.isBlank(bisInspPblm.getObjId())){
            return false;
        }
        // 设置regId 关键性字段
        bisInspPblm.setRegid(pcDto.getId());
        if(StringUtils.isBlank(bisInspPblm.getRegid())){
            return false;
        }

        return true;
    }

    private boolean setColumnOfRequiredByWunt(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,ImpPblmEnum impPblmEnum){
        return this.setColumnOfRequiredBySvwt(bisInspPblm,lhp,userId,impPblmEnum);
    }


    /** 设置必要的字段方法 主要不同之处在于获取objId和regId **/
    private boolean setColumnOfRequired(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,String orgType){
        ImpPblmEnum impPblmEnum = ImpPblmEnum.getEnumByOrgType(orgType);
        if(impPblmEnum == null){
            return false;
        }
        switch (impPblmEnum){
            case IMP_REVER:
                return this.setColumnOfRequiredRever(bisInspPblm, lhp, userId,impPblmEnum);
            case IMP_WAGA:
                return this.setColumnOfRequiredWaga(bisInspPblm, lhp, userId,impPblmEnum);
            case IMP_EMPWT:
                return this.setColumnOfRequiredByJs(bisInspPblm,lhp,userId,impPblmEnum);
            case IMP_EMPWTRUN:
                return this.setColumnOfRequiredByYx(bisInspPblm,lhp,userId,impPblmEnum);
            case IMP_SD:
                return this.setColumnOfRequiredBySd(bisInspPblm,lhp,userId,impPblmEnum);
            case IMP_SWHS:
                return this.setColumnOfRequiredBySwhs(bisInspPblm,lhp,userId,impPblmEnum);
            case IMP_WIU:
                return this.setColumnOfRequiredByWiu(bisInspPblm,lhp,userId,impPblmEnum);
            case IMP_SVWT:
                return this.setColumnOfRequiredBySvwt(bisInspPblm,lhp,userId,impPblmEnum);
            case IMP_WUNT:
                return this.setColumnOfRequiredByWunt(bisInspPblm,lhp,userId,impPblmEnum);
            default:
                return false;
        }
    }
    /** 设置问题标准 ，暂时两种标准 **/
    private boolean setColumnOfSpecial(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,String orgType){
        ImpPblmEnum impPblmEnum = ImpPblmEnum.getEnumByOrgType(orgType);
        if(impPblmEnum == null){
            return false;
        }
        switch (impPblmEnum){
            case IMP_REVER:
                return this.setColumnOfSpecialByObjInsp(bisInspPblm,lhp,userId,orgType);
            case IMP_WAGA:
                return this.setColumnOfSpecialByObjInsp(bisInspPblm,lhp,userId,orgType);
            case IMP_EMPWT:
                return this.setColumnOfSpecialByObjKey(bisInspPblm,lhp,userId,orgType);
            case IMP_EMPWTRUN:
                return this.setColumnOfSpecialByObjKey(bisInspPblm,lhp,userId,orgType);
            case IMP_SD:
                return this.setColumnOfSpecialByObjInsp(bisInspPblm,lhp,userId,orgType);
            case IMP_SWHS:
                return this.setColumnOfSpecialByObjInsp(bisInspPblm,lhp,userId,orgType);
            case IMP_WIU:
                return this.setColumnOfSpecialByObjInsp(bisInspPblm,lhp,userId,orgType);
            case IMP_SVWT:
                return this.setColumnOfSpecialByObjInsp(bisInspPblm,lhp,userId,orgType);
            case IMP_WUNT:
                return this.setColumnOfSpecialByObjInsp(bisInspPblm,lhp,userId,orgType);
            default:
                return false;
        }
    }

    private String getGroupIdByName(String groupName,String userId,String orgType){
        List<BisInspAll> list = impPblmDao.getGroupList(userId, orgType);
        List<BisInspAll> groupNamesList = list.stream().filter(b -> b.getPnm().equals(groupName)).collect(Collectors.toList());
        if(groupNamesList.size() == 1){
            return groupNamesList.get(0).getId();
        }else {
            return "";
        }
    }
    private List<BisInspAll> getGroupIdByNameList(String groupName,String userId,String orgType){
        List<BisInspAll> list = impPblmDao.getGroupList(userId, orgType);
        List<BisInspAll> groupNamesList = list.stream().filter(b -> b.getPnm().equals(groupName)).collect(Collectors.toList());
        // 组名一样，很尴尬，先取第一个
        return groupNamesList;
    }

    /** 在解析时就判断一下数据正确与否 **/
    private List<LinkedHashMap<String,Object>> checkHasObjPblm(List<LinkedHashMap<String,Object>> listParse,String userId,String orgType){
        for(LinkedHashMap<String,Object> lhp : listParse){
            try{

                if(ArrayUtils.contains(checkedOrgTypes,orgType)){
                    // 检查一下此种问题标准是否匹配
                    List<ObjInspPblms> objPblmsList = this.getObjInspPblmsList(lhp,orgType);
                    if(objPblmsList.size() != 1){
                        this.setWarnField(lhp);
                    }
                }

                // 检查一下组别
                String groupId = this.getGroupIdByName(MapUtils.getString(lhp,"groupName"),userId,orgType);
                if(StringUtils.isBlank(groupId)){
                    this.setWarnFieldGroupName(lhp);
                }

                // 工程运行检查一下工程名称和单位名称是否匹配
                if(ImpPblmEnum.getEnumByOrgType(orgType) == IMP_EMPWTRUN){
                    ImpPblmKeyReg keyReg = new ImpPblmKeyReg();
                    keyReg.setDwNm(MapUtils.getString(lhp,"dwNm"));
                    keyReg.setGcNm(MapUtils.getString(lhp,"nm"));
                    keyReg.setObjType(orgType.replaceFirst("^0*",""));
                    keyReg.setGroupId(groupId);
                    List<ImpPblmKeyReg> keyRegList = impPblmDao.getImpKeyRegList(keyReg);
                    if(keyRegList == null || keyRegList.size() != 1){
                        this.setWarnFieldEmpwt(lhp);
                    }
                }
                // 工程建设检查一下工程名称和单位名称和标段名称是匹配
                if(ImpPblmEnum.getEnumByOrgType(orgType) == IMP_EMPWT){
                    ImpPblmKeyReg keyReg = new ImpPblmKeyReg();
                    keyReg.setBdNm(MapUtils.getString(lhp,"bdNm"));
                    keyReg.setDwNm(MapUtils.getString(lhp,"dwNm"));
                    keyReg.setGcNm(MapUtils.getString(lhp,"nm"));
                    keyReg.setObjType(orgType.replaceFirst("^0*",""));
                    keyReg.setGroupId(groupId);
                    List<ImpPblmKeyReg> keyRegList = impPblmDao.getImpKeyRegList(keyReg);
                    if(keyRegList == null || keyRegList.size() != 1){
                        this.setWarnFieldEmpwtRun(lhp);
                    }
                }

            }catch (Exception e){
                this.setWarnField(lhp);
                e.printStackTrace();
            }
        }
        return listParse;
    }
    private void setWarnField(LinkedHashMap<String,Object> lhp){
        lhp.put("inspPblmCode",lhp.get("inspPblmCode") + WARN);
        lhp.put("inspPblmCate",lhp.get("inspPblmCate") + WARN);
        lhp.put("attachSheet",lhp.get("attachSheet") + WARN);
    }
    private void setWarnFieldGroupName(LinkedHashMap<String,Object> lhp){
        lhp.put("groupName",lhp.get("groupName") + WARN);
    }
    private void setWarnFieldEmpwt(LinkedHashMap<String,Object> lhp){
        lhp.put("nm",lhp.get("nm") + WARN);
        lhp.put("dwNm",lhp.get("dwNm") + WARN);
        lhp.put("bdNm",lhp.get("bdNm") + WARN);
    }
    private void setWarnFieldEmpwtRun(LinkedHashMap<String,Object> lhp){
        lhp.put("nm",lhp.get("nm") + WARN);
        lhp.put("dwNm",lhp.get("dwNm") + WARN);
    }

    private List<ObjInspPblms> getObjInspPblmsList(LinkedHashMap<String,Object> lhp,String orgType){
        List<ObjInspPblms> objInspPblmsList = new ArrayList<>();

        String dcType = Integer.toString(Integer.parseInt(orgType));
        // 从问题标准库OBJ_INSP_PBLMS 里获取数据
        ObjInspPblmsParam objInspPblmsParam = new ObjInspPblmsParam();
        // 根据 问题序号(SN_NUM)，严重程度(INSP_PBLM_CATE)，督查类型(TYPE),附件序号（ATTACH），SHEET序号（SHEET）
        // 1.问题序号(SN_NUM)
        String pblmCode = MapUtils.getString(lhp,"inspPblmCode");
        if(StringUtils.isNotBlank(pblmCode) && ImpUtil.checkIsInt(pblmCode)){
            objInspPblmsParam.setSnNum(pblmCode.trim());
        }else {
            return objInspPblmsList;
        }
        // 2.严重程度(INSP_PBLM_CATE)
        String inspPblmCate = MapUtils.getString(lhp,"inspPblmCate");
        if(inspPblmCate != null){
            objInspPblmsParam.setInspPblmCate(inspPblmCate);
        }else {
            return objInspPblmsList;
        }
        // 3.督查类型(TYPE)
        objInspPblmsParam.setType(dcType);
        // 4.附件序号（ATTACH）和 SHEET
        boolean state = this.setAttachSheet(objInspPblmsParam,lhp);
        if(!state){
            return objInspPblmsList;
        }
        // 得到问题标准
//        ObjInspPblms objInspPblms = objInspPblmsDao.getBy(objInspPblmsParam);
        objInspPblmsList = objInspPblmsDao.findList(objInspPblmsParam);
        return objInspPblmsList;
    }

    private KeyRegPblm getKeyRegPblm(LinkedHashMap<String,Object> lhp,String attachType){
        KeyRegPblm keyRegPblm = new KeyRegPblm();

        // 获取严重程度
        String inspPblmCate = MapUtils.getString(lhp,"inspPblmCate");
        if(inspPblmCate == null){
            return keyRegPblm;
        }

        // 问题类别
        String pblmType = MapUtils.getString(lhp,"inspPblmName").trim();

        try{
            // 1.获取 违规行为附件编号，违规行为问题标准序号
            String attachWg = MapUtils.getString(lhp,"attachWg");
            String attachWgSn = MapUtils.getString(lhp,"attachWgSn");
            List<ObjKeyPblms> objKeyPblmsWgList = this.getObjKeyPblmsList(attachWg,attachWgSn,inspPblmCate,attachType,pblmType);
//            if(attachType.equals("水利工程运行")){
//                if(checkIsInt(attachWg)){
//                    // 完全一样，只是有一个sheet为null，当它为int的时候，sheet是null?
//                    objKeyPblmsWgList = objKeyPblmsWgList.stream().filter(x -> StringUtils.isBlank(x.getSheet())).collect(Collectors.toList());
//                }
//            }
            if(objKeyPblmsWgList.size() == 1){
                keyRegPblm.setPblmsTypeId(objKeyPblmsWgList.get(0).getId());
                keyRegPblm.setInspPblmName(objKeyPblmsWgList.get(0).getInspPblmsName());
                keyRegPblm.setInspPblmType(objKeyPblmsWgList.get(0).getPblmType());
            }

            // 2.获取 合同管理附件编号，合同管理问题标准序号
            String attachHetong = MapUtils.getString(lhp,"attachHetong");
            String attachHetongSn = MapUtils.getString(lhp,"attachHetongSn");
            List<ObjKeyPblms> objKeyPblmsHtList = this.getObjKeyPblmsList(attachHetong,attachHetongSn,inspPblmCate,attachType,pblmType);
            if(objKeyPblmsHtList.size() == 1){
                keyRegPblm.setPblmsId(objKeyPblmsHtList.get(0).getId());
                if(StringUtils.isBlank(keyRegPblm.getInspPblmName())){
                    keyRegPblm.setInspPblmName(objKeyPblmsHtList.get(0).getInspPblmsName());
                }
                if(StringUtils.isBlank(keyRegPblm.getInspPblmType())){
                    keyRegPblm.setInspPblmType(objKeyPblmsHtList.get(0).getPblmType());
                }

            }

            // 3.获取 质量安全附件编号，质量安全问题标准序号
            String attachQua = MapUtils.getString(lhp,"attachQua");
            String attachQuaSn = MapUtils.getString(lhp,"attachQuaSn");
            List<ObjKeyPblms> objKeyPblmsQuaList = this.getObjKeyPblmsList(attachQua,attachQuaSn,inspPblmCate,attachType,pblmType);
            if(objKeyPblmsQuaList.size() == 1){
                keyRegPblm.setQualityTypeId(objKeyPblmsQuaList.get(0).getId());
                if(StringUtils.isBlank(keyRegPblm.getInspPblmName())){
                    keyRegPblm.setInspPblmName(objKeyPblmsQuaList.get(0).getInspPblmsName());
                }
                if(StringUtils.isBlank(keyRegPblm.getInspPblmType())){
                    keyRegPblm.setInspPblmType(objKeyPblmsQuaList.get(0).getPblmType());
                }
            }

            // 4.获取 缺陷管理附件编号，缺陷管理问题标准序号
            String attachDe = MapUtils.getString(lhp,"attachDe");
            String attachDeSn = MapUtils.getString(lhp,"attachDeSn");
            List<ObjKeyPblms> objKeyPblmsDeList = this.getObjKeyPblmsList(attachDe,attachDeSn,inspPblmCate,attachType,pblmType);
            if(objKeyPblmsDeList.size() == 1){
                keyRegPblm.setDefectTypeId(objKeyPblmsDeList.get(0).getId());
                if(StringUtils.isBlank(keyRegPblm.getInspPblmName())){
                    keyRegPblm.setInspPblmName(objKeyPblmsDeList.get(0).getInspPblmsName());
                }
                if(StringUtils.isBlank(keyRegPblm.getInspPblmType())){
                    keyRegPblm.setInspPblmType(objKeyPblmsDeList.get(0).getPblmType());
                }
            }

        }catch (Exception e){
            e.printStackTrace();
            return new KeyRegPblm();
        }

        return keyRegPblm;
    }
    private List<ObjKeyPblms> getObjKeyPblmsList(String attachSheet,String sn,String inspPblmCate,String attachType,String pblmType){
        List<ObjKeyPblms> objKeyPblmsList = new ArrayList<>();

        if(attachSheet == null || sn == null){
            return objKeyPblmsList;
        }

        // 从问题标准库OBJ_KEY_PBLMS 里获取数据
        ObjKeyPblmsParam objKeyPblmsParam = new ObjKeyPblmsParam();
        // 根据 问题序号(SN_NUM)，严重程度(INSP_PBLM_CATE) ,附件序号（ATTACH），SHEET序号（SHEET）
        // 1.问题序号(SN_NUM)
        objKeyPblmsParam.setSn(sn.trim());
        // 2.严重程度(INSP_PBLM_CATE)
        objKeyPblmsParam.setInspPblmCate(inspPblmCate);
        // 3.附件序号（ATTACH）和 SHEET
        boolean state = this.setAttachSheetKeyReg(objKeyPblmsParam,attachSheet);
        if(!state){
            return objKeyPblmsList;
        }
        // 4.水利工程类型
        objKeyPblmsParam.setAttachType(attachType);
        // 5.问题类别
        objKeyPblmsParam.setPblmType(pblmType);

        // 得到问题标准
        objKeyPblmsList = objKeyPblmsDao.findList(objKeyPblmsParam);

        return objKeyPblmsList;
    }
    private boolean setAttachSheetKeyReg(ObjKeyPblmsParam objKeyPblmsParam,String attachSheet){
        if(attachSheet == null){
            return false;
        }else {
            if(attachSheet.contains("-")){
                String[] attachSheetArr =  attachSheet.split("-");
                if(attachSheetArr.length == 2){
                    objKeyPblmsParam.setAttach(attachSheetArr[0].trim());
                    objKeyPblmsParam.setSheet(attachSheetArr[1].trim());
                }else {
                    return false;
                }
            }else {
                if(ImpUtil.checkIsInt(attachSheet) && attachSheet.length() == 1){
                    objKeyPblmsParam.setAttach(attachSheet);
                }else {
                    return false;
                }
            }

            return true;
        }
    }

    private boolean setAttachSheet(ObjInspPblmsParam objInspPblmsParam,LinkedHashMap<String,Object> lhp){
        Object attachSheet = lhp.get("attachSheet");
        if(attachSheet == null){
            return false;
        }else {
            String attachSheetStr = attachSheet.toString();
            if(attachSheetStr.contains("-")){
                String[] attachSheetArr =  attachSheetStr.split("-");
                if(attachSheetArr.length == 2){
                    objInspPblmsParam.setAttach(attachSheetArr[0].trim());
                    objInspPblmsParam.setSheet(attachSheetArr[1].trim());
                }else {
                    return false;
                }
            }else {
                if(ImpUtil.checkIsInt(attachSheetStr) && attachSheetStr.length() == 1){
                    objInspPblmsParam.setAttach(attachSheetStr);
                    // sheet 1
                    objInspPblmsParam.setSheet("1");
                }else {
                    return false;
                }
            }

            return true;
        }
    }



    private boolean setColumnOfSpecialByObjInsp(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,String orgType){
        // 得到问题标准List
        List<ObjInspPblms> objInspPblmsList = this.getObjInspPblmsList(lhp,orgType);
        // 获取问题标准
        ObjInspPblms objInspPblms;
        if(objInspPblmsList.size() == 1){
            objInspPblms = objInspPblmsList.get(0);
            if(objInspPblms == null){
                return false;
            }
        }else{
            return false;
        }

        // 字段 6）：INSP_PBLM_TYPE       督查问题类型   ->    从 objInspPblms 里获取
        bisInspPblm.setInspPblmType(objInspPblms.getSort2());
        // 字段 7）：INSP_PBLM_CODE       督查问题编码   ->    从 objInspPblms 里获取
        bisInspPblm.setInspPblmCode(objInspPblms.getSnNum());
        // 字段 8）：INSP_PBLM_NAME       督查问题名称   ->     从 objInspPblms 里获取
        bisInspPblm.setInspPblmName(objInspPblms.getInspPblmsName());
        // 字段30）：PBLMS_TYPE_ID        标准库唯一问题id,可用于存放172(违规行为)
        bisInspPblm.setPblmsTypeId(objInspPblms.getGuid());

        return true;
    }

    private boolean setColumnOfSpecialByObjKey(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,String orgType){
        // 得到问题标准List
        String attachType = "";
        if("004".equals(orgType)){
            attachType = "水利工程建设";
        }else if("007".equals(orgType)){
            attachType = "水利工程运行";
        }
        KeyRegPblm keyRegPblm = this.getKeyRegPblm(lhp,attachType);

        // 获取问题标准
        // 字段 6）：INSP_PBLM_TYPE       督查问题类型   ->    从 keyRegPblm 里获取
        bisInspPblm.setInspPblmType(keyRegPblm.getInspPblmType());
        // 字段 8）：INSP_PBLM_NAME       督查问题名称   ->     从 keyRegPblm 里获取 事实上这里也取类型
        bisInspPblm.setInspPblmName(keyRegPblm.getInspPblmType());

        // 字段30）：PBLMS_TYPE_ID        标准库唯一问题id,可用于存放172(违规行为)
        bisInspPblm.setPblmsTypeId(keyRegPblm.getPblmsTypeId());
        bisInspPblm.setPblmsId(keyRegPblm.getPblmsId());
        bisInspPblm.setQualityTypeId(keyRegPblm.getQualityTypeId());
        bisInspPblm.setDefectTypeId(keyRegPblm.getDefectTypeId());

        String problemType = "";
        if(StringUtils.isNotBlank(keyRegPblm.getPblmsTypeId())){
            problemType = "0";
        }else if(StringUtils.isNotBlank(keyRegPblm.getPblmsId())){
            problemType = "2";
        }else if(StringUtils.isNotBlank(keyRegPblm.getQualityTypeId())){
            problemType = "1";
        }else if(StringUtils.isNotBlank(keyRegPblm.getDefectTypeId())){
            problemType = "3";
        }
        // 字段35）：PROBLEM_TYPE     问题类别（0违规，1质量，2合同，3工程缺陷） -
        bisInspPblm.setProblemType(problemType);

        return true;
    }

    private boolean setColumnOfOther(BisInspPblm bisInspPblm,LinkedHashMap<String,Object> lhp,String userId,String orgType){

        ImpPblmEnum impPblmEnum = ImpPblmEnum.getEnumByOrgType(orgType);

        // 字段 4）：INSP_GROUP_ID        督查组ID       - (无值项)
        // 字段 5）：PGUID                复查原问题PGUID    - (无值项)
        // 字段 9）：INSP_PBLM_DESC       督查问题描述 = 详细描述 -> 从Excel解析而来
        // 字段10）：INSP_ADD_DESC        督查问题地址描述精确度县乡街道  -  (无值项)
        // 字段11）：PBLM_LONG            问题经度     -   (无值项)
        // 字段12）：PBLM_LAT             问题纬度     -   (无值项)
        // 字段13）：IF_CASE_PBLM         是否典型问题，0否，1是  -> 从Excel解析而来
        // 字段14）：INSP_PBLM_ORG_NAME   问题责任单位   - (无值项)
        // 字段15）：PBLM_PERS_NAME       问题责任人     - (无值项)
        // 字段16）：INSP_PBLM_CATE       督查问题严重程度:0一般，1较重，2严重;3：特别严重   -> 从Excel解析而来
        // 字段17）：PBLM_STAT            问题状态
        bisInspPblm.setPblmStat("1");
        // 字段18）：REVI_OPIN            复查意见   -  (无值项)
        // 字段19）：REVI_CONC            复查状态2已复查，1未复查，0新问题  -
        // 字段20）：REVI_ORG_GUID        复核单位GUID   -
        // 字段21）：DATA_STAT            数据状态0:暂存;1:已提交;2:已上报;3:退回;4:审核;5:审办;6:整改通知;7:整改反馈;8:销号;9:删除
        // 字段22）：COLL_TIME            采集时间
        // 上报时间，填的话按填写的,不填的话，当前
//        bisInspPblm.setCollTime(new Date());
        try{
            bisInspPblm.setCollTime((Date)lhp.get("collTime"));
        }catch (Exception e){
            bisInspPblm.setCollTime(new Date());
        }

        // 字段23）：REC_PERS             操作记录人员
        // 上报人，如果填写按填写的人，不填，按当前用户
        bisInspPblm.setRecPers(this.getRecPers(lhp,userId));

        // 字段24）：NOTE                 备注
        // 字段26）：COMMON_FILE_IDS      上传文件id,多个问题用','分隔
        bisInspPblm.setCommonFileIds("-1");
        // 字段27）：FILE_NO              问题附件  -
        // 字段28）：FILE_NO_NUMBER       问题序号  -
        // 字段29）：PBLMS_ID             非172问题标准父节点id,172工程(合同问题)标准库id
        // 字段32）：CWS_CODE             工程code   -
        // 字段33）：VILLAGE_CODE         村code     -
        // 字段34）：HAS_VEDIO            是否有多媒体   根据path是否为空来判断
        // 设置是否有多媒体 1无 0有
        Object path = lhp.get("path");
        if(path != null && StringUtils.isNotBlank(path.toString())){
            bisInspPblm.setHasVedio("1");
        }else {
            bisInspPblm.setHasVedio("0");
        }
        // 字段35）：PROBLEM_TYPE         问题类别（0违规，1质量，2合同，3工程缺陷） -
        // 字段36）：QUALITY_TYPE_ID      172质量缺陷标准id   -
        // 字段37）：DEFECT_TYPE_ID       172工程缺陷标准id   -
        // 字段38）：FDBK_ID              172问题最新反馈id   -
        // 字段39）：ITEM_ID              对应规则id          -
        // 字段40）：WATER_USER_ID        用水户id
        // 字段41）：QUOTE 是否引用 1是 0否
        bisInspPblm.setQuote("0");

        // 字段19）：REVI_CONC            复查状态2已复查，1未复查，0新问题  -
        bisInspPblm.setReviConc("0");
        // 字段21）：DATA_STAT            数据状态0:暂存;1:已提交;2:已上报;3:退回;4:审核;5:审办;6:整改通知;7:整改反馈;8:销号;9:删除;
        bisInspPblm.setDataStat("1");

        // 和督查类型相关的几个字段
        // 必要字段 3）：督查对象类型1小水库，2人饮工程，3水毁工程，4 172工程建设,5水文司地下水,6水闸，7 172工程运行
        bisInspPblm.setObjType(impPblmEnum.getObjType());
        // 字段31）：VILL_TYPE   问题类型，0小水库，1行政村，2饮水工程，3水源地，4水毁，5地下水，6人饮（落实情况）,7水闸，8水利工程建设，9水利工程运行
        bisInspPblm.setVillType(impPblmEnum.getVillType());

        return true;
    }

    private String getRecPers(LinkedHashMap<String,Object> lhp,String userId){

        try {
            String persName = MapUtils.getString(lhp,"persName");
            if(StringUtils.isBlank(persName)){
                return userId;
            }

            // 查找有无此用户
            UserListByCurUserParam userParam = new UserListByCurUserParam();
            userParam.setCurUserId(userId);
            userParam.setPersName(persName);
            userParam.setPageNum(1);
            userParam.setPageSize(20);

            PageInfo<PersListDto> list = bisInspAllRlationPersService.listByCurUser(userParam);

            if(list != null){
                List<PersListDto> persListDtos = list.getList();
                if(persListDtos != null && persListDtos.size() > 0){
                    return persListDtos.get(0).getGuid();
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return userId;
    }

    private BisInspRsvrRgstrPcDto getRsvrRgstrDto(String userId,String pType,String code,String id){
        if(StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(pType)
                && StringUtils.isNotBlank(id) && StringUtils.isNotBlank(code)){
            TypeParam typeParam = new TypeParam();
            typeParam.setPresId(userId);
            typeParam.setpType(pType);
            typeParam.setId(id);
//            typeParam.setCode(code);
            typeParam.setRsName(code);
            List<BisInspRsvrRgstrPcDto> list = bisInspRsvrRgstrDao.findPcPage(typeParam);
            if(list.size() == 1){
                return list.get(0);
            }
        }
        return null;
    }
    private BisInspWagaRgstrDto getWagaRgstrDto(String userId,String pType,String code,String id){
        if(StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(pType)
                && StringUtils.isNotBlank(id) && StringUtils.isNotBlank(code)){
            TypeParam typeParam = new TypeParam();
            typeParam.setPresId(userId);
            typeParam.setpType(pType);
            typeParam.setPlnaId(id);
//            typeParam.setCode(code);
            typeParam.setRsName(code);
            List<BisInspWagaRgstrDto> list = attWagaRgstrDao.findWagaPage(typeParam);
            if(list.size() == 1){
                return list.get(0);
            }
        }
        return null;
    }
    private BisInspSdRgstrDto getSdRgstrDto(String userId,String pType,String code,String id){
        if(StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(pType)
                && StringUtils.isNotBlank(id) && StringUtils.isNotBlank(code)){
            TypeParam typeParam = new TypeParam();
            typeParam.setPresId(userId);
            typeParam.setpType(pType);
            typeParam.setId(id);
            typeParam.setCode(code);
            List<BisInspSdRgstrDto> list = bisInspSdRgstrDao.findSdPage(typeParam);
            if(list.size() == 1){
                return list.get(0);
            }
        }
        return null;
    }
    private BisInspRgstrDto getRgstrCommon(String userId,String pType,String code,String id){
        ImpPblmEnum impPblmEnum = ImpPblmEnum.getEnumByObjType(pType);
        if(impPblmEnum == null){
            return null;
        }
        switch (impPblmEnum){
            case IMP_SWHS:
                return this.getSwhsRgstr(userId,pType,code,id);
            case IMP_WIU:
                return this.getWiuRgstr(userId, pType, code, id);
            case IMP_SVWT:
                return this.getSvwtRgstr(userId, pType, code, id);
            case IMP_WUNT:
                return this.getWuntRgstr(userId, pType, code, id);
            default:
                return null;
        }
    }
    private BisInspRgstrDto getSwhsRgstr(String userId,String pType,String code,String id){
        if(StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(pType)
                && StringUtils.isNotBlank(id) && StringUtils.isNotBlank(code)){
            TypeParam typeParam = new TypeParam();
            typeParam.setPresId(userId);
            typeParam.setpType(pType);
            typeParam.setId(id);
            typeParam.setCode(code);
            List<BisInspRgstrDto> list = bisInspSwhsRgstrDao.findSwhsPage(typeParam);
            if(list.size() == 1){
                return list.get(0);
            }
        }
        return null;
    }
    private BisInspRgstrDto getWiuRgstr(String userId,String pType,String code,String id){
        if(StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(pType)
                && StringUtils.isNotBlank(id) && StringUtils.isNotBlank(code)){
            TypeParam typeParam = new TypeParam();
            typeParam.setPresId(userId);
            typeParam.setpType(pType);
            typeParam.setId(id);
            typeParam.setCode(code);
            List<BisInspRgstrDto> list = bisInspWiuRgstrDao.findWiuList(typeParam);
            if(list.size() == 1){
                return list.get(0);
            }
        }
        return null;
    }
    private BisInspRgstrDto getSvwtRgstr(String userId,String pType,String nm,String id){
        if(StringUtils.isNotBlank(userId) && StringUtils.isNotBlank(pType)
                && StringUtils.isNotBlank(id) && StringUtils.isNotBlank(nm)){
            TypeParam typeParam = new TypeParam();
            typeParam.setPresId(userId);
            typeParam.setpType(pType);
            typeParam.setId(id);
            typeParam.setRsName(nm);
            List<BisInspRgstrDto> list = null;
            if(ImpPblmEnum.getEnumByObjType(pType) == IMP_SVWT){
                list = bisInspSvwtAreaRgstrDao.findSvwtAreaList(typeParam);
            }
            if(ImpPblmEnum.getEnumByObjType(pType) == IMP_WUNT){
                list = bisInspSvwtWuntRgstrDao.findSvwtWuntList(typeParam);
            }
            if(list != null && list.size() == 1){
                return list.get(0);
            }
        }
        return null;
    }

    private BisInspRgstrDto getWuntRgstr(String userId,String pType,String nm,String id){
        return this.getSvwtRgstr(userId,pType,nm,id);
    }



    /**
     *  只入库一次，只取一次，取完及时删除
     */
    private List<LinkedHashMap<String,Object>> getParseDataByRedis(String cacheId){
        // 取出
        List<LinkedHashMap<String,Object>> listParse = redisTemplate.opsForList().range(cacheId, 0, -1);
        // 删除
        redisTemplate.delete(cacheId);
        return listParse;
    }


    private String uploadFileExcel(MultipartFile file){
        String excleName = UuidUtil.uuid();
        // 获取到Excel的存放路径
        String parentPath = getDateFormatPath(this.impExcelBashPath);
        // 把文件流写入到此位置
        boolean success = gwComFileService.writeFile(excleName, ImpUtil.XLS, file, parentPath);
        if(success){
            return parentPath + File.separator + excleName + ".xls";
        }else {
            return "";
        }
    }

    private String uploadFileExcelCommon(MultipartFile file){
        // 临时路径
        String parentPath = getDateFormatPath(this.impExcelBashPath);
        String filePath = "";
        try{
            filePath = ExpAndImpUtil.upload(file,parentPath);
        }catch (Exception e){
            e.printStackTrace();
        }
        return filePath;
    }

    private String uploadFileZip(MultipartFile file){
        String zipName = UuidUtil.uuid();
        // 先存放到一个临时路径，再剪切或复制到图片路径下
        String parentPath = getDateFormatPath(this.impExcelBashPath);
        // 把文件流写入到此位置
        boolean success = gwComFileService.writeFile(zipName, ImpUtil.ZIP, file, parentPath);
        String filePath = "";
        if(success){
            // 解压
            try {
                filePath = parentPath + File.separator + zipName + "." + ImpUtil.ZIP;
                //解压到此文件夹
                ZipUtil.unzip(new File(filePath), parentPath);
            }catch (Exception e){
                filePath = "";
                e.printStackTrace();
            }
        }
        return filePath;
    }

    private String uploadFileZipCommon(MultipartFile file){
        // 先存放到一个临时路径，再剪切或复制到图片路径下
        String parentPath = getDateFormatPath(this.impExcelBashPath);
        String filePath = "";
        try{
            filePath = ExpAndImpUtil.uploadFileZipCommon(file,parentPath);
        }catch (Exception e){
            e.printStackTrace();
        }
        return filePath;
    }





}