fj-dc/.svn/pristine/8a/8a466ac7fe2c8901461764ce239a78c25a301656.svn-base

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

import cn.com.goldenwater.core.service.AbstractCrudService;
import cn.com.goldenwater.dcproj.dao.*;
import cn.com.goldenwater.dcproj.dto.BisInspTaskDthDayDto;
import cn.com.goldenwater.dcproj.dto.TacCountDto;
import cn.com.goldenwater.dcproj.dto.TacPblmInfoDto;
import cn.com.goldenwater.dcproj.model.*;
import cn.com.goldenwater.dcproj.param.TacInspYearBatchAreaParam;
import cn.com.goldenwater.dcproj.param.TacPblmInfoParam;
import cn.com.goldenwater.dcproj.param.TacPblmSubjectParam;
import cn.com.goldenwater.dcproj.param.TacWorkerBParam;
import cn.com.goldenwater.dcproj.service.GwComFileService;
import cn.com.goldenwater.dcproj.service.TacObjSubjectService;
import cn.com.goldenwater.dcproj.service.TacPblmInfoService;
import cn.com.goldenwater.dcproj.service.TacProvincePlanDictService;
import cn.com.goldenwater.dcproj.utils.Constant;
import cn.com.goldenwater.dcproj.utils.DateUtils;
import cn.com.goldenwater.id.util.UuidUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mysql.cj.util.TimeUtil;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.logging.Logger;

/**
 * @author lune
 * @date 2019-6-19
 */
@Service
@Transactional
public class TacPblmInfoServiceImpl extends AbstractCrudService<TacPblmInfo, TacPblmInfoParam> implements TacPblmInfoService {
    private org.slf4j.Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private TacPblmInfoDao tacPblmInfoDao;
    @Autowired
    private TacProvincePblmInfoDao tacProvincePblmInfoDao;
    @Autowired
    private TacPblmSubjectDao tacPblmSubjectDao;
    @Autowired
    private GwComFileService gwComFileService;
    @Autowired
    private TacObjSubjectService objSubjectService;
    @Autowired
    private TacObjSubject515Dao tacObjSubject515Dao;
    @Autowired
    private TacPawpRgstrDao tacPawpRgstrDao;
    @Autowired
    private TacProvincePlanDictService tacProvincePlanDictService;
    @Autowired
    private TacObjSubjectDao tacObjSubjectDao;
    @Autowired
    private TacWorkerBDao workerBDao;


    public TacPblmInfoServiceImpl(TacPblmInfoDao tacPblmInfoDao) {
        super(tacPblmInfoDao);
        this.tacPblmInfoDao = tacPblmInfoDao;
    }

    private static Map<String, String> stbMap = new HashedMap();

    static {
        stbMap.put("1", "前期与设计");
        stbMap.put("2", "建设管理");
        stbMap.put("3", "计划下达与执行");
        stbMap.put("4", "资金使用与管理");
        stbMap.put("5", "工程质量");
        stbMap.put("6", "工程安全");
    }

    @Override
    public void updatePblm(TacPblmInfo tacPblmInfo) {
        TacPblmSubjectParam subjectParam = new TacPblmSubjectParam();
        subjectParam.setPblmId(tacPblmInfo.getId());
        tacPblmSubjectDao.deleteBy(subjectParam);
        if (tacPblmInfo.getGwComFileList() != null && tacPblmInfo.getGwComFileList().size() > 0) {
            tacPblmInfo.setHasVedio("1");
        } else {
            tacPblmInfo.setHasVedio("0");
        }
        if (tacPblmInfo.getSn() == 0) {
            String sn = this.tacPblmInfoDao.getMaxSn(tacPblmInfo.getProvince());
            if (StringUtils.isBlank(sn)) {
                sn = "0";
            }
            try {
                tacPblmInfo.setSn(Integer.parseInt(sn) + 1);
            } catch (NumberFormatException e) {
                tacPblmInfo.setSn(1);
            }
        }
        tacPblmInfo.setObjType("8");
        tacPblmInfo.setSubjectNames(retSubjectNames(tacPblmInfo.getPblmSubjectList()));
        tacPblmInfo.setSubjectIds(retSubjectIds(tacPblmInfo.getPblmSubjectList()));
        tacPblmInfoDao.update(tacPblmInfo);
        addPblmSubject(tacPblmInfo.getSubjectNames(), tacPblmInfo.getSubjectIds(), tacPblmInfo.getPblmSubjectList(), tacPblmInfo.getId());
        gwComFileService.updateBiz(tacPblmInfo.getGwComFileList(), tacPblmInfo.getId());
    }

    public String retSubjectIds(List<TacPblmSubject> pblmSubjectList) {
        String ret = "";
        for (TacPblmSubject tacPblmSubject : pblmSubjectList) {
            ret = ret + tacPblmSubject.getSubId() + ",";
        }
        if (ret.length() > 0) {
            ret = ret.substring(0, ret.length() - 1);
        }
        return ret;

    }

    public String retSubjectNames(List<TacPblmSubject> pblmSubjectList) {
        String ret = "";
        if(null==pblmSubjectList||pblmSubjectList.isEmpty()){
            return ret;
        }
        for (TacPblmSubject tacPblmSubject : pblmSubjectList) {
            //根据ID获取单位性质名称
            TacObjSubject tacObjSubject = tacObjSubjectDao.get(tacPblmSubject.getSubId());
            String subName = tacObjSubject.getSysName() == null ? "" : tacObjSubject.getSysName();
            ret = ret + subName + ",";
            tacPblmSubject.setSubName(subName);
        }
        if (ret.length() > 0) {
            ret = ret.substring(0, ret.length() - 1);
        }
        return ret;

    }

    @Override
    public int insertPblm(TacPblmInfo tacPblmInfo) {
       if (tacPblmInfo.getSn() == 0) {
            String sn = this.tacPblmInfoDao.getMaxSn(tacPblmInfo.getProvince());
            if (StringUtils.isBlank(sn)) {
                sn = "0";
            }
           try {
               tacPblmInfo.setSn(Integer.parseInt(sn) + 1);
           } catch (NumberFormatException e) {
               tacPblmInfo.setSn(1);
           }
       }
        if (tacPblmInfo.getGwComFileList() != null && tacPblmInfo.getGwComFileList().size() > 0) {
            tacPblmInfo.setHasVedio("1");
        } else {
            tacPblmInfo.setHasVedio("0");
        }
        tacPblmInfo.setObjType("8");
        tacPblmInfo.setSubjectNames(retSubjectNames(tacPblmInfo.getPblmSubjectList()));
        tacPblmInfo.setSubjectIds(retSubjectIds(tacPblmInfo.getPblmSubjectList()));

        tacPblmInfoDao.insert(tacPblmInfo);
        addPblmSubject(tacPblmInfo.getSubjectNames(), tacPblmInfo.getSubjectIds(), tacPblmInfo.getPblmSubjectList(), tacPblmInfo.getId());
        gwComFileService.updateBiz(tacPblmInfo.getGwComFileList(), tacPblmInfo.getId());

        return 0;
    }

    @Override
    public void addPblmSubject(String subjectNames, String subjectIds, List<TacPblmSubject> pblmSubjects, String pblmId) {
       /* if (pblmSubjects == null || pblmSubjects.isEmpty()) {
            if (StringUtils.isNotBlank(subjectNames)) {
                String[] subjects = subjectNames.split(",");
                for (int i = 0; i < subjects.length; i++) {
                    if (StringUtils.isNotBlank(subjectIds)) {//单位名称有值，单位性质为空
                        String[] subjeids = subjectIds.split(",");
                        if (i < subjeids.length) {////若subjeids单位性质与subjects单位名称长度不同则出现报错
                            TacObjSubject objSubject = objSubjectService.get(subjeids[i]);
                            if (objSubject != null) {
                                TacPblmSubject subject = new TacPblmSubject();
                                subject.setId(UuidUtil.uuid());
                                subject.setPblmId(pblmId);
                                subject.setSubId(subjeids[i]);
                                subject.setIntm(new Date());
                                subject.setSubName(objSubject.getSubName());
                                subject.setUnitNm(subjects[i]);
                                tacPblmSubjectDao.insert(subject);
                            }
                        } else {
                            TacPblmSubject subject = new TacPblmSubject();
                            subject.setId(UuidUtil.uuid());
                            subject.setPblmId(pblmId);
//                        subject.setSubId(subjeids[i]);
                            subject.setIntm(new Date());
//                        subject.setSubName(objSubject.getSubName());
                            subject.setUnitNm(subjects[i]);
                            tacPblmSubjectDao.insert(subject);
                        }
                    } else {
                        TacPblmSubject subject = new TacPblmSubject();
                        subject.setId(UuidUtil.uuid());
                        subject.setPblmId(pblmId);
                        subject.setIntm(new Date());
                        subject.setUnitNm(subjects[i]);
                        tacPblmSubjectDao.insert(subject);
                    }

                }
            } else if (StringUtils.isBlank(subjectNames) && StringUtils.isNotBlank(subjectIds)) {
                String[] subjeids = subjectIds.split(",");
                for (int i = 0; i < subjeids.length; i++) {
                    TacObjSubject objSubject = objSubjectService.get(subjeids[i]);
                    TacPblmSubject subject = new TacPblmSubject();
                    subject.setId(UuidUtil.uuid());
                    subject.setPblmId(pblmId);
                    subject.setSubId(subjeids[i]);
                    subject.setIntm(new Date());
                    subject.setSubName(objSubject.getSubName());
                    tacPblmSubjectDao.insert(subject);
                }
            }
            return;
        }*/
        //删除之前责任单位，并重新添加新的
        TacPblmSubjectParam tacPblmSubjectParam = new TacPblmSubjectParam();
        tacPblmSubjectParam.setPblmId(pblmId);
        tacPblmSubjectDao.deleteBy(tacPblmSubjectParam);
        //添加责任单位
        int i = 1;
        for (TacPblmSubject subject : pblmSubjects) {
            subject.setId(UuidUtil.uuid());
            subject.setPblmId(pblmId);
            Calendar cal = Calendar.getInstance();
            subject.setIntm(DateUtils.DateAdd("s", i * 10, cal).getTime());
            logger.info("-------------------------subject set tm:" + DateUtils.DateAdd("s", 10, cal).getTime().toString() + "-------------------------")
            ;
            i++;
            tacPblmSubjectDao.insert(subject);
        }
    }


    @Override
    public List<TacPblmSubject> findSubjectList(String id, String subjectNames, String subjectIds) {
        TacPblmSubjectParam pblmSubjectParam = new TacPblmSubjectParam();
        pblmSubjectParam.setPblmId(id);
        List<TacPblmSubject> pblmSubjectList = tacPblmSubjectDao.findList(pblmSubjectParam);
        /*
        if (pblmSubjectList != null && !pblmSubjectList.isEmpty()) {
            return pblmSubjectList;
        } else {
            pblmSubjectList = new ArrayList<>();
            if (StringUtils.isNotBlank(subjectNames)) {
                String[] subjects = subjectNames.split(",");
                String[] subjeids = subjectIds.split(",");
                for (int i = 0; i < subjeids.length; i++) {
                    TacObjSubject objSubject = objSubjectService.get(subjeids[i]);
                    if (objSubject == null) {
                        objSubject = tacObjSubject515Dao.get(subjeids[i]);
                    }
                    if (objSubject != null) {
                        TacPblmSubject subject = new TacPblmSubject();
                        subject.setPblmId(id);
                        subject.setSubId(subjeids[i]);
                        subject.setSubName(objSubject.getSubName());
                        subject.setIntm(new Date());
                        subject.setUnitNm(subjects[i]);
                        pblmSubjectList.add(subject);
                    }
                }
            }
        }
         */
        return pblmSubjectList;
    }

    @Override
    public List<TacCountDto> countPblmInfoByType(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = tacPblmInfoDao.countPblmInfoByType(pblmInfoParam);
        return list;
    }

    @Override
    public List<TacCountDto> countPblmInfoBySub(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> pblmDtos = tacPblmInfoDao.countPblmInfoBySub(pblmInfoParam);
        if (pblmDtos.size() > 0) {
            Map<String, String> map = new LinkedHashMap<>();
            StringBuffer subTempIds = new StringBuffer("");
            String subIds = "";
            pblmDtos.forEach(tacCountDto -> {
                map.put(tacCountDto.getCode() + tacCountDto.getName(), tacCountDto.getCount());
                subTempIds.append("'").append(tacCountDto.getCode()).append("',");
            });
            if (subTempIds.length() > 0) {
                subIds = subTempIds.substring(0, subTempIds.length() - 1);
            }
            TacPblmSubjectParam subjectParam = new TacPblmSubjectParam();
            subjectParam.setSubId(subIds);
            List<TacCountDto> subDtos = tacPblmSubjectDao.countSubBySub(subjectParam);
            if (CollectionUtils.isNotEmpty(subDtos)) {
                subDtos.stream().forEach(subDto -> {
                    String codeZero = map.get(subDto.getCode() + "0");
                    String codeOne = map.get(subDto.getCode() + "1");
                    String codeTWO = map.get(subDto.getCode() + "2");
                    subDto.setCount("0");
                    if (StringUtils.isNotBlank(codeZero)) {
                        subDto.setNormal(codeZero);
                        subDto.setCount(String.valueOf(Integer.valueOf(codeZero)));
                    }
                    if (StringUtils.isNotBlank(codeOne)) {
                        subDto.setHeavier(codeOne);
                        subDto.setCount(String.valueOf(Integer.valueOf(subDto.getCount()) + Integer.valueOf(codeOne)));
                    }
                    if (StringUtils.isNotBlank(codeTWO)) {
                        subDto.setSerious(codeTWO);
                        subDto.setCount(String.valueOf(Integer.valueOf(subDto.getCount()) + Integer.valueOf(codeTWO)));
                    }
                });
                return subDtos;
            }
        }
        return null;
    }

    @Override
    public List<TacCountDto> countPblmInfoBySubNew(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> pblmDtos = new ArrayList<>();
        //按照数据字典配置的新阶段汇总统计（专家现场意见稿，相应配置新阶段）
        //RgstrId=0时为专家现场意见稿
        if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
            //专家现场意见稿数据表为TAC_PBLM_INFO
            pblmDtos = tacPblmInfoDao.countPblmInfoBySubNew(pblmInfoParam);
        } else {
            //RgstrId为当前阶段id时为相应配置阶段
            //相应配置阶段问题数据表为TAC_PROVINCE_PBLM_INFO
            pblmDtos = tacProvincePblmInfoDao.countPblmInfoBySubJdNew(pblmInfoParam);
        }
        if (pblmDtos.size() > 0) {
            Map<String, String> map = new LinkedHashMap<>();
            StringBuffer subTempIds = new StringBuffer("");
            String subIds = "";
            pblmDtos.forEach(tacCountDto -> {
                map.put(tacCountDto.getCode() + tacCountDto.getName(), tacCountDto.getCount());
                subTempIds.append("'").append(tacCountDto.getCode()).append("',");
            });
            if (subTempIds.length() > 0) {
                subIds = subTempIds.substring(0, subTempIds.length() - 1);
            }
            TacPblmSubjectParam subjectParam = new TacPblmSubjectParam();
            subjectParam.setSubId(subIds);
            List<TacCountDto> subDtos = tacPblmSubjectDao.countSubBySub(subjectParam);
            if (CollectionUtils.isNotEmpty(subDtos)) {
                subDtos.stream().forEach(subDto -> {
                    String codeZero = map.get(subDto.getCode() + "0");
                    String codeOne = map.get(subDto.getCode() + "1");
                    String codeTWO = map.get(subDto.getCode() + "2");
                    subDto.setCount("0");
                    if (StringUtils.isNotBlank(codeZero)) {
                        subDto.setNormal(codeZero);
                        subDto.setCount(String.valueOf(Integer.valueOf(codeZero)));
                    }
                    if (StringUtils.isNotBlank(codeOne)) {
                        subDto.setHeavier(codeOne);
                        subDto.setCount(String.valueOf(Integer.valueOf(subDto.getCount()) + Integer.valueOf(codeOne)));
                    }
                    if (StringUtils.isNotBlank(codeTWO)) {
                        subDto.setSerious(codeTWO);
                        subDto.setCount(String.valueOf(Integer.valueOf(subDto.getCount()) + Integer.valueOf(codeTWO)));
                    }
                });
                return subDtos;
            }
        }
        return pblmDtos;
    }

    @Override
    public List<TacCountDto> countPblmInfoByAdCode(TacPblmInfoParam pblmInfoParam) {
        Map<String, TacCountDto> result = new LinkedHashMap<>();
        List<TacCountDto> list = tacPblmInfoDao.countPblmInfoByAdCode(pblmInfoParam);
        if (CollectionUtils.isNotEmpty(list)) {
            //问题区分赋值
            setProblemValue(result, list);
            //问题数量总计
            convertCount(result);
            return new ArrayList<>(result.values());
        }
        return list;
    }

    @Override
    public List<TacCountDto> countPblmInfoByAdCodeNew(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = new ArrayList<>();
        //汇总统计条形图以地市进行分类查询
        if (StringUtils.isNotBlank(pblmInfoParam.getUseObjFlag()) && "0".equals(pblmInfoParam.getUseObjFlag())) {
            //汇总统计饼图以工程类别进行分类查询
            //按照数据字典配置的新阶段汇总统计（专家现场意见稿，相应配置新阶段）
            if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
                list = tacPblmInfoDao.countPblmInfoByObjTypeNew(pblmInfoParam);
            } else {
                list = tacProvincePblmInfoDao.countPblmInfoByObjTypeJdNew(pblmInfoParam);
            }
        } else {
            //按照数据字典配置的新阶段汇总统计（专家现场意见稿，相应配置新阶段）
            if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
                list = tacPblmInfoDao.countPblmInfoByAdCodeNew(pblmInfoParam);
            } else {
                list = tacProvincePblmInfoDao.countPblmInfoByAdCodeJdNew(pblmInfoParam);
            }
            if (list.size() > 0) {
                Map<String, String> map = new LinkedHashMap<>();
                StringBuffer AdCodeTempIds = new StringBuffer("");
                String AdCodeIds = "";
                list.forEach(tacCountDto -> {
                    map.put(tacCountDto.getCode() + tacCountDto.getName(), tacCountDto.getCount());
                    AdCodeTempIds.append("'").append(tacCountDto.getCode()).append("',");
                });
                if (AdCodeTempIds.length() > 0) {
                    AdCodeIds = AdCodeTempIds.substring(0, AdCodeTempIds.length() - 1);
                }
                TacInspYearBatchAreaParam areaParam = new TacInspYearBatchAreaParam();
                areaParam.setAdCode(AdCodeIds);
                List<TacCountDto> subDtos = tacPblmInfoDao.countAdNameByAdAdCade(areaParam);
                if (CollectionUtils.isNotEmpty(subDtos)) {
                    subDtos.forEach(subDto -> {
                        String codeZero = map.get(subDto.getCode() + "0");
                        String codeOne = map.get(subDto.getCode() + "1");
                        String codeTWO = map.get(subDto.getCode() + "2");
                        subDto.setCount("0");
                        if (StringUtils.isNotBlank(codeZero)) {
                            subDto.setNormal(codeZero);
                            subDto.setCount(String.valueOf(Integer.valueOf(codeZero)));
                        }
                        if (StringUtils.isNotBlank(codeOne)) {
                            subDto.setHeavier(codeOne);
                            subDto.setCount(String.valueOf(Integer.parseInt(subDto.getCount()) + Integer.parseInt(codeOne)));
                        }
                        if (StringUtils.isNotBlank(codeTWO)) {
                            subDto.setSerious(codeTWO);
                            subDto.setCount(String.valueOf(Integer.parseInt(subDto.getCount()) + Integer.parseInt(codeTWO)));
                        }
                    });
                    return subDtos;
                }
            }
        }

        return list;
    }

    @Override
    public List<TacCountDto> countPblmInfoByStb(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = tacPblmInfoDao.countPblmInfoByStb(pblmInfoParam);
        pblmInfoParam.setIfCasePblm(Constant.STRING_ONE);
        Integer isCasePblm = tacPblmInfoDao.countIfCasePblm(pblmInfoParam);
        pblmInfoParam.setIfCasePblm(Constant.STRING_ZERO);
        Integer isNotCasePblm = tacPblmInfoDao.countIfCasePblm(pblmInfoParam);
        if (CollectionUtils.isNotEmpty(list)) {
            TacCountDto tacCount = list.get(0);
            tacCount.setIsCasePblmCount(String.valueOf(isCasePblm));
            tacCount.setIsNotCasePblmCount(String.valueOf(isNotCasePblm));
            Map<String, TacCountDto> result = new LinkedHashMap<>();
            //问题区分赋值
            setProblemValue(result, list);
            //问题数量总计
            convertCount(result);
            return new ArrayList<>(result.values());
        }
        return list;
    }

    @Override
    public List<TacCountDto> countPblmInfoByStbNew(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = new ArrayList<>();
        Integer isCasePblm = null;
        Integer isNotCasePblm = null;
        //按照数据字典配置的新阶段汇总统计（专家现场意见稿，相应配置新阶段）
        //RgstrId=0时为专家现场意见稿
        if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
            //专家现场意见稿数据表为TAC_PBLM_INFO
            list = tacPblmInfoDao.countPblmInfoByStbZjNew(pblmInfoParam);
            pblmInfoParam.setIfCasePblm(Constant.STRING_ONE);
            isCasePblm = tacPblmInfoDao.countIfCasePblmNew(pblmInfoParam);
            pblmInfoParam.setIfCasePblm(Constant.STRING_ZERO);
            isNotCasePblm = tacPblmInfoDao.countIfCasePblmNew(pblmInfoParam);
        } else {
            //RgstrId为当前阶段id时为相应配置阶段
            //相应配置阶段问题数据表为TAC_PROVINCE_PBLM_INFO
            list = tacProvincePblmInfoDao.countPblmInfoByStbJdNew(pblmInfoParam);
            pblmInfoParam.setIfCasePblm(Constant.STRING_ONE);
            isCasePblm = tacProvincePblmInfoDao.countIfCasePblmJdNew(pblmInfoParam);
            pblmInfoParam.setIfCasePblm(Constant.STRING_ZERO);
            isNotCasePblm = tacProvincePblmInfoDao.countIfCasePblmJdNew(pblmInfoParam);
        }
        if (CollectionUtils.isNotEmpty(list)) {
            TacCountDto tacCount = list.get(0);
            tacCount.setIsCasePblmCount(String.valueOf(isCasePblm));
            tacCount.setIsNotCasePblmCount(String.valueOf(isNotCasePblm));
            Map<String, TacCountDto> result = new LinkedHashMap<>();
            //问题区分赋值
            setProblemValue(result, list);
            //问题数量总计
            convertCount(result);
            return new ArrayList<>(result.values());
        }
        return list;
    }

    @Override
    public int updatePblmInfoList(TacPblmInfoDto dto) {
        if (dto == null) {
            return 0;
        }
        if (dto.getList() != null) {
            dto.getList().forEach(tacPblmInfo -> {
                tacPblmInfo.setIfCasePblm(dto.getIfCasePblm());
                tacPblmInfoDao.update(tacPblmInfo);
            });
        }
        return 1;
    }

    @Override
    public PageInfo<TacPblmInfo> findPageInfoNew2(TacPblmInfoParam pblmInfoParam) {
        pblmInfoParam.setPblmTableName("TAC_PBLM_INFO");
        PageHelper.startPage(pblmInfoParam.getPageNum(), pblmInfoParam.getPageSize());
        //1. 获取最新阶段ID
        if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId())) {
            TacPawpRgstr tacPawpRgstr = tacPawpRgstrDao.get(pblmInfoParam.getRgstrId());
            Optional.ofNullable(tacPawpRgstr).ifPresent(r -> {
                if (StringUtils.isNotBlank(r.getTaskId())) {
                    pblmInfoParam.setPblmTableName("TAC_PROVINCE_PBLM_INFO");
                    pblmInfoParam.setStepId(r.getTaskId());
                }
            });
        }

        List<TacPblmInfo> list = tacPblmInfoDao.findPageInfoNew2(pblmInfoParam);
        return new PageInfo<>(list);
    }

    @Autowired
    private TaskDthDayCountDao taskDthDayCountDao;

    @Override
    public PageInfo<TacPblmInfo> findPageInfoNew(TacPblmInfoParam pblmInfoParam) {
        PageHelper.startPage(pblmInfoParam.getPageNum(), pblmInfoParam.getPageSize());
        List<TacPblmInfo> list = tacPblmInfoDao.findPageInfoNew(pblmInfoParam);
        return new PageInfo<>(list);
    }

    @Override
    public PageInfo<TacPblmInfo> findProvincePblmInfo(TacPblmInfoParam pblmInfoParam) {
        BisInspTaskDthDayDto bisInspTaskDthDayDto = new BisInspTaskDthDayDto();
        bisInspTaskDthDayDto.setOrgId(pblmInfoParam.getOrgId());
        pblmInfoParam.setStepId(tacProvincePlanDictService.getJcStepId(bisInspTaskDthDayDto.getOrgId()));
        PageHelper.startPage(pblmInfoParam.getPageNum(), pblmInfoParam.getPageSize());
        List<TacPblmInfo> list = tacPblmInfoDao.findProvincePblmInfo(pblmInfoParam);
        return new PageInfo<>(list);
    }

    @Override
    public PageInfo<TacPblmInfo> findPageInfoZLorTPY(TacPblmInfoParam pblmInfoParam) {
        PageHelper.startPage(pblmInfoParam.getPageNum(), pblmInfoParam.getPageSize());
        List<TacPblmInfo> list = tacPblmInfoDao.findPageInfoZLorTPY(pblmInfoParam);
        return new PageInfo<TacPblmInfo>(list);
    }

    @Override
    public PageInfo<TacPblmInfo> findPageJieduanInfo(TacPblmInfoParam pblmInfoParam) {
        PageHelper.startPage(pblmInfoParam.getPageNum(), pblmInfoParam.getPageSize());
        List<TacPblmInfo> list = tacPblmInfoDao.findPageJieduanInfo(pblmInfoParam);
        return new PageInfo<TacPblmInfo>(list);
    }

    @Override
    public PageInfo<TacPblmInfo> findPageJieduanZLorTPY(TacPblmInfoParam pblmInfoParam) {
        PageHelper.startPage(pblmInfoParam.getPageNum(), pblmInfoParam.getPageSize());
        List<TacPblmInfo> list = tacPblmInfoDao.findPageJieduanZLorTPY(pblmInfoParam);
        return new PageInfo<TacPblmInfo>(list);
    }


    @Override
    public List<TacCountDto> countPblmInfoByCase(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = tacPblmInfoDao.countPblmInfoByCase(pblmInfoParam);
        return list;
    }

    @Override
    public List<TacCountDto> countPblmInfoByQlttv(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = tacPblmInfoDao.countPblmInfoByQlttv(pblmInfoParam);
        return list;
    }

    @Override
    public List<TacCountDto> countPblmInfoByQt(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> result = new ArrayList<>();
        if (StringUtils.isNotBlank(pblmInfoParam.getStbClaName())) {
            pblmInfoParam.setStbClaName(stbNameformat(pblmInfoParam.getStbClaName()));
        }
        if (StringUtils.isBlank(pblmInfoParam.getUseObjFlag()) || Constant.STRING_ONE.equals(pblmInfoParam.getUseObjFlag())) {
            result.addAll(tacPblmInfoDao.countPblmInfoByQt(pblmInfoParam));
        } else if (Constant.STRING_TWO.equals(pblmInfoParam.getUseObjFlag())) {
            result.addAll(tacPblmInfoDao.countPblmInfoObjByQt(pblmInfoParam));
        }
        if (CollectionUtils.isNotEmpty(result)) {
            result.forEach(countDto -> {
                countDto.setName(countDto.getShowName());
                countDto.setShowName(Constant.STRING_BLANK);
            });
        }
        return result;
    }

    @Override
    public List<TacCountDto> countPblmInfoByQtNew(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> result = new ArrayList<>();
        if (StringUtils.isNotBlank(pblmInfoParam.getStbClaName())) {
            pblmInfoParam.setStbClaName(stbNameformat(pblmInfoParam.getStbClaName()));
        }
        //不统计问题分类中类型为其他的稽察数据
        if (StringUtils.isBlank(pblmInfoParam.getUseObjFlag()) || Constant.STRING_ONE.equals(pblmInfoParam.getUseObjFlag())) {
            //按照数据字典配置的新阶段汇总统计（专家现场意见稿，相应配置新阶段）
            if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
                result.addAll(tacPblmInfoDao.countPblmInfoByQtNew(pblmInfoParam));
            } else {
                result.addAll(tacProvincePblmInfoDao.countPblmInfoByQtJdNew(pblmInfoParam));
            }
        } else if (Constant.STRING_TWO.equals(pblmInfoParam.getUseObjFlag())) {
            if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
                result.addAll(tacPblmInfoDao.countPblmInfoObjByQtNew(pblmInfoParam));
            } else {
                result.addAll(tacProvincePblmInfoDao.countPblmInfoObjByQtJdNew(pblmInfoParam));
            }
        }
        if (CollectionUtils.isNotEmpty(result)) {
            result.forEach(countDto -> {
                countDto.setName(countDto.getShowName());
                countDto.setShowName(Constant.STRING_BLANK);
            });
        }
        return result;
    }

    @Override
    public List<TacCountDto> countPblmInfoMaxByQt(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = new ArrayList<>();
        Map<String, TacCountDto> map = new LinkedHashMap<>();
        if (StringUtils.isNotBlank(pblmInfoParam.getStbClaName())) {
            pblmInfoParam.setStbClaName(stbNameformat(pblmInfoParam.getStbClaName()));
        }
        if (StringUtils.isBlank(pblmInfoParam.getUseObjFlag()) || Constant.STRING_ONE.equals(pblmInfoParam.getUseObjFlag())) {
            list.addAll(tacPblmInfoDao.countPblmInfoByQt(pblmInfoParam));
        } else if (Constant.STRING_TWO.equals(pblmInfoParam.getUseObjFlag())) {
            list.addAll(tacPblmInfoDao.countPblmInfoObjByQt(pblmInfoParam));
        }
        if (CollectionUtils.isNotEmpty(list)) {
            list.forEach(dto -> {
                String key = dto.getName();
                dto.setName(stbNameformat(key));
                if (map.containsKey(key)) {
                    //数据转换
                    compareDto(map, key, dto);
                } else {
                    map.put(key, dto);
                }
            });
        }
        List<TacCountDto> result = new ArrayList<>(map.values());
        return result;
    }

    @Override
    public List<TacCountDto> countPblmInfoMaxByQtNew(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> list = new ArrayList<>();
        Map<String, TacCountDto> map = new LinkedHashMap<>();
        if (StringUtils.isNotBlank(pblmInfoParam.getStbClaName())) {
            pblmInfoParam.setStbClaName(stbNameformat(pblmInfoParam.getStbClaName()));
        }
        if (StringUtils.isBlank(pblmInfoParam.getUseObjFlag()) || Constant.STRING_ONE.equals(pblmInfoParam.getUseObjFlag())) {
            if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
                list.addAll(tacPblmInfoDao.countPblmInfoByQtNew(pblmInfoParam));
            } else {
                list.addAll(tacProvincePblmInfoDao.countPblmInfoByQtJdNew(pblmInfoParam));
            }
        } else if (Constant.STRING_TWO.equals(pblmInfoParam.getUseObjFlag())) {
            if (StringUtils.isNotBlank(pblmInfoParam.getRgstrId()) && "0".equals(pblmInfoParam.getRgstrId())) {
                list.addAll(tacPblmInfoDao.countPblmInfoObjByQtNew(pblmInfoParam));
            } else {
                list.addAll(tacProvincePblmInfoDao.countPblmInfoObjByQtJdNew(pblmInfoParam));
            }
        }
        if (CollectionUtils.isNotEmpty(list)) {
            list.forEach(dto -> {
                String key = dto.getName();
                dto.setName(stbNameformat(key));
                if (map.containsKey(key)) {
                    //数据转换
                    compareDto(map, key, dto);
                } else {
                    map.put(key, dto);
                }
            });
        }
        List<TacCountDto> result = new ArrayList<>(map.values());
        return result;
    }

    /**
     * 数据转换
     *
     * @param map
     * @param key
     * @param currDto
     */
    private void compareDto(Map<String, TacCountDto> map, String key, TacCountDto currDto) {
        if (map.get(key) == null) {
            return;
        }
        TacCountDto dto = map.get(key);
        if (StringUtils.isBlank(currDto.getCount())) {
            return;
        }
        if (StringUtils.isBlank(dto.getCount()) || (Long.valueOf(currDto.getCount()) > Long.valueOf(dto.getCount()))) {
            map.put(key, currDto);
        }
    }

    /**
     * 问题数量总计
     *
     * @param result
     */
    private void convertCount(Map<String, TacCountDto> result) {
        result.values().stream().forEach(tacCountDto -> {
            Integer count = 0;
            if (StringUtils.isNotBlank(tacCountDto.getNormal())) {
                count += Integer.valueOf(tacCountDto.getNormal());
            }
            if (StringUtils.isNotBlank(tacCountDto.getHeavier())) {
                count += Integer.valueOf(tacCountDto.getHeavier());
            }
            if (StringUtils.isNotBlank(tacCountDto.getSerious())) {
                count += Integer.valueOf(tacCountDto.getSerious());
            }
            tacCountDto.setCount(count.toString());
        });
    }

    /**
     * 问题区分赋值
     *
     * @param result
     */
    private void setProblemValue(Map<String, TacCountDto> result, List<TacCountDto> list) {
        list.stream().forEach(tacCountDto -> {
            StringBuilder sb = new StringBuilder();
            String name = tacCountDto.getName();
            if (StringUtils.isNotBlank(name)) {
                sb.append(name);
            }
            if (result.keySet().contains(sb.toString())) {
                TacCountDto dto = result.get(sb.toString());
                String normal = dto.getNormal();
                String heavier = dto.getHeavier();
                String serious = dto.getSerious();
                String count = tacCountDto.getCount();
                if (Constant.STRING_ZERO.equals(tacCountDto.getCode())) {
                    dto.setNormal(StringUtils.isBlank(normal) ? count : String.valueOf(Integer.valueOf(normal) + Integer.valueOf(count)));
                }
                if (Constant.STRING_ONE.equals(tacCountDto.getCode())) {
                    dto.setHeavier(StringUtils.isBlank(heavier) ? count : String.valueOf(Integer.valueOf(heavier) + Integer.valueOf(count)));
                }
                if (Constant.STRING_TWO.equals(tacCountDto.getCode())) {
                    dto.setSerious(StringUtils.isBlank(serious) ? count : String.valueOf(Integer.valueOf(serious) + Integer.valueOf(count)));
                }
            } else {
                if (Constant.STRING_ZERO.equals(tacCountDto.getCode())) {
                    tacCountDto.setNormal(tacCountDto.getCount());
                }
                if (Constant.STRING_ONE.equals(tacCountDto.getCode())) {
                    tacCountDto.setHeavier(tacCountDto.getCount());
                }
                if (Constant.STRING_TWO.equals(tacCountDto.getCode())) {
                    tacCountDto.setSerious(tacCountDto.getCount());
                }
                result.put(sb.toString(), tacCountDto);
            }
        });
    }

    /**
     * 问题发生频度，定性一级分类转换
     *
     * @param key
     * @return
     */
    public static String stbNameformat(String key) {
        if (key == null) {
            return "";
        }
        if (stbMap.containsKey(key)) {
            return stbMap.get(key);
        }
        if (stbMap.containsValue(key)) {
            for (String k : stbMap.keySet()) {
                if (key.equals(stbMap.get(k))) {
                    return k;
                }
            }
        }
        return "";
    }

    @Override
    public List<TacCountDto> countPblmInfoByObj(TacPblmInfoParam pblmInfoParam) {
        List<TacCountDto> tacCountDtos = tacPblmInfoDao.countPblmInfoByObj(pblmInfoParam);
        return tacCountDtos;
    }

    @Override
    public List<String> getLeaderId(String id) {
        return tacPblmInfoDao.getLeaderId(id);
    }
}