fj-dc/.svn/pristine/a3/a34c1440d611279c617475254afe160eae48eae7.svn-base

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

import cn.com.goldenwater.core.service.AbstractCrudService;
import cn.com.goldenwater.dcproj.constValue.BisInspEnum;
import cn.com.goldenwater.dcproj.constValue.SplitValue;
import cn.com.goldenwater.dcproj.dao.BisInspPblmDao;
import cn.com.goldenwater.dcproj.dao.BisInspYndrdmpRgstrDao;
import cn.com.goldenwater.dcproj.dto.BisInspYndrdmpRgstrDto;
import cn.com.goldenwater.dcproj.model.*;
import cn.com.goldenwater.dcproj.param.*;
import cn.com.goldenwater.dcproj.service.*;
import cn.com.goldenwater.dcproj.util.PdfPTableUtil;
import cn.com.goldenwater.dcproj.utils.*;
import cn.com.goldenwater.id.util.UuidUtil;
import com.alibaba.fastjson.JSONArray;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.itextpdf.text.*;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfWriter;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.List;
import java.util.*;
import java.util.stream.Collectors;

import static cn.com.goldenwater.dcproj.util.CheckUtil.check;

/**
 * @author lhc
 * @date 2021-3-23
 */
@Service
@Transactional
public class BisInspYndrdmpRgstrServiceImpl extends AbstractCrudService<BisInspYndrdmpRgstr, BisInspYndrdmpRgstrParam> implements BisInspYndrdmpRgstrService, BisInspObjStrategy {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private AttYndepBaseService attYndepBaseService;

    @Autowired
    private BisInspYndrdmpRgstrDao bisInspYndrdmpRgstrDao;

    @Autowired
    private BisInspYnDrdmpItService bisInspYnDrdmpItService;

    @Autowired
    private BisInspYnDrdmpSafetyService bisInspYnDrdmpSafetyService;

    @Autowired
    private BisInspYnDrdmpSystemService bisInspYnDrdmpSystemService;

    @Autowired
    private BisInspPblmDao bisInspPblmDao;

    @Autowired
    private GwComFileService gwComFileService;

    @Value("${web.upload-path}")
    public String webUploadPath;

    public BisInspYndrdmpRgstrServiceImpl(BisInspYndrdmpRgstrDao bisInspYndrdmpRgstrDao) {
        super(bisInspYndrdmpRgstrDao);
        this.bisInspYndrdmpRgstrDao = bisInspYndrdmpRgstrDao;
    }

    @Override
    public int insert(BisInspYndrdmpRgstr bisInspYndrdmpRgstr) {
        String uuid = UuidUtil.uuid();
        bisInspYndrdmpRgstr.setId(uuid);
        bisInspYndrdmpRgstr.setIntm(new Date());
        bisInspYndrdmpRgstr.setUptm(new Date());
        bisInspYndrdmpRgstr.setDataStat("0");
        return this.bisInspYndrdmpRgstrDao.insert(bisInspYndrdmpRgstr);
    }

    @Override
    public int update(BisInspYndrdmpRgstr bisInspYndrdmpRgstr) {
        if (StringUtils.isBlank(bisInspYndrdmpRgstr.getId()) ||
                StringUtils.isNotBlank(bisInspYndrdmpRgstr.getRgstrId())) {
            // rgstrId 不为 空 时，传给ID
            bisInspYndrdmpRgstr.setId(bisInspYndrdmpRgstr.getRgstrId());
        }
        check(StringUtils.isNotBlank(bisInspYndrdmpRgstr.getId()), "缺少登记表编码！");

        bisInspYndrdmpRgstr.setUptm(new Date());
        int ret = bisInspYndrdmpRgstrDao.update(bisInspYndrdmpRgstr);
        // 更新基础表信息
        updateAttBase(bisInspYndrdmpRgstr);
        return ret;
    }

    private void updateAttBase(BisInspYndrdmpRgstr rgstr) {
        BisInspYndrdmpRgstr r = get(rgstr.getId());
        AttYndepBase attWiuqhBase = attYndepBaseService.getObjId(r.getObjId());
        attWiuqhBase.setAdCode(rgstr.getAdCode());
        attWiuqhBase.setAdName(rgstr.getAdName());
        attWiuqhBase.setCenterX(rgstr.getCenterX());
        attWiuqhBase.setCenterY(rgstr.getCenterY());
        attWiuqhBase.setDepName(rgstr.getDepName());
        attWiuqhBase.setDepPers(rgstr.getDepPers());
        attWiuqhBase.setDepPersTel(rgstr.getDepPersTel());
        attWiuqhBase.setGdX(rgstr.getGdX());
        attWiuqhBase.setGdY(rgstr.getGdY());
        attWiuqhBase.setLoc(rgstr.getLoc());
        attWiuqhBase.setNote(rgstr.getNote());
        attWiuqhBase.setUtLead(rgstr.getUtLead());
        attWiuqhBase.setPrincipalTel(rgstr.getPrincipalTel());
        attYndepBaseService.update(attWiuqhBase);
    }

    @Override
    public int delete(String id) {
        return this.bisInspYndrdmpRgstrDao.delete(id);
    }


    @Override
    public void insertObj(BisInspAllObj bisInspAllObj, String persId) {
        BisInspYndrdmpRgstr b = new BisInspYndrdmpRgstr();
        AttYndepBase base = attYndepBaseService.get(bisInspAllObj.getCode());
        BeanUtils.copyProperties(base, b);
        b.setObjId(bisInspAllObj.getObjId());
        b.setId(UuidUtil.uuid());
        b.setIntm(new Date());
        b.setUptm(new Date());
        b.setDataStat("0");
        b.setState("0");
        b.setItStat("0");
        b.setSafetyStat("0");
        b.setYstemStat("0");
        /* 添加 登记表 */
        bisInspYndrdmpRgstrDao.insert(b);
        // 添加 子表
        bisInspYnDrdmpItService.insert(Builder.of(BisInspYnDrdmpItParam::new).with(BisInspYnDrdmpItParam::setRgstrId, b.getId()).build());
        bisInspYnDrdmpSafetyService.insert(Builder.of(BisInspYnDrdmpSafetyParam::new).with(BisInspYnDrdmpSafetyParam::setRgstrId, b.getId()).build());
        bisInspYnDrdmpSystemService.insert(Builder.of(BisInspYnDrdmpSystemParam::new).with(BisInspYnDrdmpSystemParam::setRgstrId, b.getId()).build());
    }

    @Override
    public String getType() {
        return BisInspEnum.YNDEP.getValue();
    }

    @Override
    public void cleanObjData(String objId) {
        BisInspYndrdmpRgstrParam rgstrParam = new BisInspYndrdmpRgstrParam();
        rgstrParam.setObjId(objId);
        List<BisInspYndrdmpRgstr> list = this.bisInspYndrdmpRgstrDao.findList(rgstrParam);
        if (list.size() > 0) {
            String id = list.get(0).getId();
            // 删除登记表
            this.bisInspYndrdmpRgstrDao.delete(id);
            // 添加 子表
            bisInspYnDrdmpItService.deleteBy(Builder.of(BisInspYnDrdmpItParam::new).with(BisInspYnDrdmpItParam::setRgstrId, id).build());
            bisInspYnDrdmpSafetyService.deleteBy(Builder.of(BisInspYnDrdmpSafetyParam::new).with(BisInspYnDrdmpSafetyParam::setRgstrId, id).build());
            bisInspYnDrdmpSystemService.deleteBy(Builder.of(BisInspYnDrdmpSystemParam::new).with(BisInspYnDrdmpSystemParam::setRgstrId, id).build());
        }
    }

    @Override
    public PageInfo findObjPageByType(TypeParam typeParam, HttpServletResponse response) {
        if (StringUtils.isNotBlank(typeParam.getAdCode())) {
            typeParam.setAdCode(String.valueOf(AdLevelUtil.SubAd(typeParam.getAdCode()).get(SplitValue.SUBAD)));
        }
        PageHelper.startPage(typeParam);
        List<BisInspYndrdmpRgstrDto> list = this.bisInspYndrdmpRgstrDao.findPageList(typeParam);
        return new PageInfo(list);
    }

    @Override
    public void updateState(Map<String, Object> map) {
        BisInspYndrdmpRgstr rgstr = get(MapUtils.getString(map, "rgstrId"));
        if (!Constant.STRING_TWO.equals(rgstr.getState()) &&
                StringUtils.isNotBlank(MapUtils.getString(map, "state"))) {
            rgstr.setUptm(new Date());
            rgstr.setState(Constant.STRING_ONE);
            switch (MapUtils.getString(map, "param")) {
                case "it":
                    rgstr.setItStat(MapUtils.getString(map, "state"));
                    break;
                case "safety":
                    rgstr.setSafetyStat(MapUtils.getString(map, "state"));
                    break;
                case "system":
                    rgstr.setYstemStat(MapUtils.getString(map, "state"));
                    break;
                default:
            }
            update(rgstr);
        }
    }

    @Override
    public Object findObjListByType(TypeParam typeParam) {
        return this.bisInspYndrdmpRgstrDao.findPageList(typeParam);
    }


    @Override
    public void exportCheckList(String id, String orgId, HttpServletResponse response) {
        String fileName = "水行政主管部门安全生产巡查检查表.pdf";
        response.setContentType("application/x-msdownload");
        try (OutputStream out = response.getOutputStream()) {
            // 修改模板内容导出新模板
            String fileNameURL = URLEncoder.encode(fileName, "UTF-8");
            response.setHeader("Content-disposition", "attachment;filename=" + fileNameURL + ";filename*=utf-8''" + fileNameURL);
            exportCheckList(id, orgId, out);
            out.flush();
        } catch (IOException | DocumentException e) {
            e.printStackTrace();
        }
    }

    private void exportCheckList(String id, String orgId, OutputStream out) throws IOException, DocumentException {
        BaseFont bfCN = BaseFont.createFont("STSongStd-Light", "UniGB-UCS2-H", false);
        // 正文的字体
        Font topFont = new Font(bfCN, 24f, Font.BOLD);
        Font headFont = new Font(bfCN, 12f, Font.BOLD);
        Font textFont = new Font(bfCN, 12f, Font.NORMAL);

        Document document = new Document();
        PdfWriter.getInstance(document, out);
        document.open();

        // 获取数据
        Map<String, Object> mapData = getCheckListData(id, orgId);

        //建立一个4列的表格
        PdfPTableUtil table = new PdfPTableUtil(new PdfPTable(new float[]{5f, 14f, 38f, 5f, 38f}));
        table.getTable().setTotalWidth(PageSize.A4.getWidth() - 20f);
        table.getTable().setLockedWidth(true);

        String adName = "";
        String duchaDate = "";
        if (!mapData.isEmpty()) {
            adName = "州（市）：" + MapUtils.getString(mapData, "shi", "                 ") +
                    "                 县（市、区）：" + MapUtils.getString(mapData, "xian", "");
            duchaDate = DateUtils.Date2Str((Date) mapData.get("time"), "yyyy-MM-dd");
        }

        table.addNoBorderPCell(new Paragraph("水行政主管部门安全生产巡查检查表", topFont),
                PdfPCell.ALIGN_CENTER, PdfPCell.ALIGN_MIDDLE, 5);

        table.addNoBorderPCell(new Paragraph("                    ", topFont),
                PdfPCell.ALIGN_CENTER, PdfPCell.ALIGN_MIDDLE, 5);

        table.addNoBorderPCell(new Paragraph(adName, textFont),
                PdfPCell.ALIGN_LEFT, PdfPCell.ALIGN_MIDDLE, 5);

        table.addNoBorderPCell(new Paragraph("巡查时间：" + duchaDate, textFont),
                PdfPCell.ALIGN_LEFT, PdfPCell.ALIGN_MIDDLE, 5);

        //加表格头部序号	类别	巡查项目	严重程度	问题描述
        String[] titleArr = {"序号", "类别", "巡查项目", "是否存在问题", "问题描述"};
        for (String aTitleArr : titleArr) {
            table.addPCell(new Paragraph(aTitleArr, headFont), PdfPCell.ALIGN_CENTER);
        }

        //加表格内容
        if (mapData.get("pblms") != null) {
            addContent(table, (List<Map<String, String>>) mapData.get("pblms"), textFont);
        }

        //第1列
        PdfPCell cell3 = new PdfPCell();
        cell3.setHorizontalAlignment(PdfPCell.ALIGN_LEFT);
        cell3.setBorder(0);
        cell3.addElement(new Paragraph("组长签名：", textFont));
        if (StringUtils.isNotBlank(MapUtils.getString(mapData, "ducha"))) {
            String imgPath = webUploadPath.replace("/upload/", "") + MapUtils.getString(mapData, "ducha");
            Image img = Image.getInstance(imgPath);
            img.setRotation((float) Math.PI / 2);
            img.setAlignment(Image.RIGHT);
            img.scaleAbsolute(100, 50);
            cell3.addElement(img);
        }
        cell3.setColspan(3);
        table.getTable().addCell(cell3);

        PdfPCell cell4 = new PdfPCell();
        cell4.setHorizontalAlignment(PdfPCell.ALIGN_LEFT);
        cell4.setBorder(0);
        cell4.addElement(new Paragraph("被检查单位责任人签名：", textFont));
        if (StringUtils.isNotBlank(MapUtils.getString(mapData, "beijiancha"))) {
            String imgPath = webUploadPath.replace("/upload/", "") + MapUtils.getString(mapData, "beijiancha");
            Image img = Image.getInstance(imgPath);
            img.setRotation((float) Math.PI / 2);
            img.setAlignment(Image.RIGHT);
            img.scaleAbsolute(100, 50);
            cell4.addElement(img);
        }
        cell4.setColspan(2);
        table.getTable().addCell(cell4);

        document.add(table.getTable());
        document.close();
    }

    private void addContent(PdfPTableUtil table, List<Map<String, String>> list, Font textFont) {
        int index = 0;
        //计算'合并列'的合并相关集合
        List<Integer> indexs;
        //每个'合并列'的初始下标集合
        List<Integer> spanStartIndex;
        //每个'合并列'的合并数量集合
        List<Integer> spanNumList;
        //取出'合并列'的所有数据计算
        List<String> ListIn = new ArrayList<>();
        for (Map<String, String> res : list) {
            ListIn.add(MapUtils.getString(res, "seq"));
        }
        spanNumList = getSpanNumList(ListIn);
        spanStartIndex = getStartIndexList(ListIn, spanNumList);
        indexs = getIndexs(list.size(), spanNumList, spanStartIndex);
        for (Map<String, String> pblm : list) {
            PdfPCell cell1 = new PdfPCell(new Paragraph(MapUtils.getString(pblm, "seq"), textFont));
            cell1.setHorizontalAlignment(PdfPCell.ALIGN_CENTER);
            cell1.setVerticalAlignment(PdfPCell.ALIGN_MIDDLE);
            setRowsSpan(indexs, spanStartIndex, spanNumList, table.getTable(), cell1, index);

            //合并列
            PdfPCell cell2 = new PdfPCell(new Paragraph(MapUtils.getString(pblm, "category"), textFont));
            cell2.setHorizontalAlignment(PdfPCell.ALIGN_CENTER);
            cell2.setVerticalAlignment(PdfPCell.ALIGN_MIDDLE);
            setRowsSpan(indexs, spanStartIndex, spanNumList, table.getTable(), cell2, index);

            table.addPCell(new Paragraph(MapUtils.getString(pblm, "prj"), textFont));

            if ("9".equals(MapUtils.getString(pblm, "seq"))) {
                table.addPCell(new Paragraph(MapUtils.getString(pblm, "desc", ""), textFont),
                        PdfPCell.ALIGN_CENTER, PdfPCell.ALIGN_MIDDLE, 2);
            } else {
                table.addPCell(new Paragraph(MapUtils.getIntValue(pblm, "count") > 0 ? "是" : "否", textFont));
                table.addPCell(new Paragraph(MapUtils.getString(pblm, "desc", ""), textFont));
            }

            index++;
        }
    }


    private Map<String, Object> getCheckListData(String id, String orgId) {
        Map<String, Object> result = new HashMap<>(6);
        BisInspYndrdmpRgstr rgstr = bisInspYndrdmpRgstrDao.get(id);
        BisInspYnDrdmpIt it = bisInspYnDrdmpItService.get(id);
        BisInspYnDrdmpSafety safety = bisInspYnDrdmpSafetyService.get(id);
        BisInspYnDrdmpSystem system = bisInspYnDrdmpSystemService.get(id);
        Optional.ofNullable(rgstr).ifPresent(r -> {
            result.put("time", r.getUptm());
            String[] ad = r.getAdFullName().split("-");
            if (ad.length == 3) {
                result.put("shi", ad[1]);
                result.put("xian", ad[2]);
            } else if (ad.length == 2) {
                result.put("shi", ad[1]);
            }

            String checkListJson = "[\n" +
                    "{\"seq\":1,\"category\":\"贯彻落实安全生产各项决策部署\",\"prj\":\"学习贯彻习近平总书记关于安全生产工作重要论述和指示批示精神情况\",\"id\":\"B5FA42944566A83F89A1505807075001\"},\n" +
                    "{\"seq\":1,\"category\":\"贯彻落实安全生产各项决策部署\",\"prj\":\"安全生产法律法规学习培训、岗位能力提升、安全生产宣传、政策解读等组织情况\",\"id\":\"B5FA42944566A83F89A1505807075002\"},\n" +
                    "{\"seq\":2,\"category\":\"落实安全生产重要政策文件规定\",\"prj\":\"水利部和流域委 2020 年以来印发的有关安全生产监督管理文件的组织落实情况\",\"id\":\"B5FA42944566A83F89A1505807075003\"},\n" +
                    "{\"seq\":2,\"category\":\"落实安全生产重要政策文件规定\",\"prj\":\"省水利厅 2020 年以来印发的有关安全生产监督管理文件的组织落实情况\",\"id\":\"B5FA42944566A83F89A1505807075004\"},\n" +
                    "{\"seq\":3,\"category\":\"落实水利行业安全生产专项整治三年活动\",\"prj\":\"落实《云南省水利行业安全生产专项整治三年行动实施方案》（云水监督〔2020〕1 号）情况\",\"id\":\"B5FA42944566A83F89A1505807075005\"},\n" +
                    "{\"seq\":3,\"category\":\"落实水利行业安全生产专项整治三年活动\",\"prj\":\"落实《云南省水利行业安全生产专项整治三年行动 2020 年重点工作措施清单》（云水监督〔2020〕8 号）情况\",\"id\":\"B5FA42944566A83F89A1505807075006\"},\n" +
                    "{\"seq\":3,\"category\":\"落实水利行业安全生产专项整治三年活动\",\"prj\":\"其他水利行业安全生产专项整治三年行动措施落实情况\",\"id\":\"B5FA42944566A83F89A1505807075007\"},\n" +
                    "{\"seq\":4,\"category\":\"落实安全生产工作责任制\",\"prj\":\"《地方党政领导干部安全生产责任制实施办法》《云南省水利系统党政领导干部安全生产责任制实施办法》（云水党〔2018〕133 号）《关于建立全省水利安全生产监管责任清单的意见》等是否有效落实\",\"id\":\"B5FA42944566A83F89A1505807075008\"},\n" +
                    "{\"seq\":5,\"category\":\"水利安全风险管控、事故隐患排查治理\",\"prj\":\"按照《水利部关于开展水利安全风险分级管控的指导意见》（水安监〔2018〕323 号）等要求组织辖区内水利生产经营单位开展危险源辨识与风险评价工作情况\",\"id\":\"B5FA42944566A83F89A1505807075009\"},\n" +
                    "{\"seq\":5,\"category\":\"水利安全风险管控、事故隐患排查治理\",\"prj\":\"针对不同风险等级制定分级管控措施的情况\",\"id\":\"B5FA42944566A83F89A1505807075010\"},\n" +
                    "{\"seq\":5,\"category\":\"水利安全风险管控、事故隐患排查治理\",\"prj\":\"对重点区域、重点项目、重点领域、重点环节、重大危险源开展重点监管等情况\",\"id\":\"B5FA42944566A83F89A1505807075011\"},\n" +
                    "{\"seq\":5,\"category\":\"水利安全风险管控、事故隐患排查治理\",\"prj\":\"按照《水利部关于进一步加强水利生产安全事故隐患排查治理工作的意见》（水安监〔2017〕409 号）要求，建立健全重大事故隐患治理督办制度情况\",\"id\":\"B5FA42944566A83F89A1505807075012\"},\n" +
                    "{\"seq\":5,\"category\":\"水利安全风险管控、事故隐患排查治理\",\"prj\":\"建立辖区内的重大事故隐患台账、采取监管措施、实行闭环管理等情况\",\"id\":\"B5FA42944566A83F89A1505807075013\"},\n" +
                    "{\"seq\":5,\"category\":\"水利安全风险管控、事故隐患排查治理\",\"prj\":\"对安全风险隐患实施清单化管理，建立问题隐患和制度措施“两个清单”情 况\",\"id\":\"B5FA42944566A83F89A1505807075014\"},\n" +
                    "{\"seq\":6,\"category\":\"安全生产事故应急预案管理\",\"prj\":\"组织制定、修编生产安全事故应急预案情况\",\"id\":\"B5FA42944566A83F89A1505807075015\"},\n" +
                    "{\"seq\":6,\"category\":\"安全生产事故应急预案管理\",\"prj\":\"预案符合实际、实用有效情况和按照相关规定审查备案情况\",\"id\":\"B5FA42944566A83F89A1505807075016\"},\n" +
                    "{\"seq\":6,\"category\":\"安全生产事故应急预案管理\",\"prj\":\"推动有效开展应急处置演练情况\",\"id\":\"B5FA42944566A83F89A1505807075017\"},\n" +
                    "{\"seq\":7,\"category\":\"水利安全生产监管执法\",\"prj\":\"建立安全生产举报制度情况\",\"id\":\"B5FA42944566A83F89A1505807075018\"},\n" +
                    "{\"seq\":7,\"category\":\"水利安全生产监管执法\",\"prj\":\"建立安全生产违法行为信息库，如实记录生产经营单位的安全生产违法行为信息情况\",\"id\":\"B5FA42944566A83F89A1505807075019\"},\n" +
                    "{\"seq\":7,\"category\":\"水利安全生产监管执法\",\"prj\":\"推进安全生产执法工作规范化、信息化等情况\",\"id\":\"B5FA42944566A83F89A1505807075020\"},\n" +
                    "{\"seq\":8,\"category\":\"水利生产防范工作\",\"prj\":\"安全生产防范工作流于形式，安全生产监管存在形式主义、官僚主义现象等情况\",\"id\":\"B5FA42944566A83F89A1505807075021\"},\n" +
                    "{\"seq\":8,\"category\":\"水利生产防范工作\",\"prj\":\"安全生产工作存在监管不到位、检查形式化等突出问题情况\",\"id\":\"B5FA42944566A83F89A1505807075022\"},\n" +
                    "{\"seq\":9,\"category\":\"安全生产信息化建设\",\"prj\":\"水利安全生产信息系统使用情况\",\"id\":\"\"},\n" +
                    "{\"seq\":9,\"category\":\"安全生产信息化建设\",\"prj\":\"水利安全生产信息系统用户启用情况，包括用户总量、未启用数量和未启用原因等情况\",\"id\":\"\"},\n" +
                    "{\"seq\":9,\"category\":\"安全生产信息化建设\",\"prj\":\"安全生产信息化建设存在的问题和下一步推进措施\",\"id\":\"\"},\n" +
                    "\n" +
                    "]";

            List<Map<String, String>> mapList = JSONArray.parseObject(checkListJson, List.class);

            List<BisInspPblm> bisInspPblmList = bisInspPblmDao.findList(Builder.of(BisInspPblmParam::new)
                    .with(BisInspPblmParam::setObjId, r.getObjId()).build());

            if (bisInspPblmList == null) {
                bisInspPblmList = new ArrayList<>();
            }

            for (Map<String, String> map : mapList) {
                map.put("desc", bisInspPblmList.stream()
                        .filter(p -> MapUtils.getString(map, "id").equals(p.getPblmsTypeId()))
                        .map(BisInspPblm::getInspPblmDesc)
                        .collect(Collectors.joining(";")));
                map.put("level", bisInspPblmList.stream()
                        .filter(p -> MapUtils.getString(map, "id").equals(p.getPblmsTypeId()))
                        .map(BisInspPblm::getInspPblmCate)
                        .distinct()
                        .map(InspPblmUtils::plbmCateDesc)
                        .collect(Collectors.joining("、")));

                map.put("count", String.valueOf(bisInspPblmList.stream()
                        .filter(p -> MapUtils.getString(map, "id").equals(p.getPblmsTypeId()))
                        .map(BisInspPblm::getPblmId)
                        .distinct()
                        .count()));

                if (!(MapUtils.getIntValue(map, "count") > 0)) {
                    String prj = MapUtils.getString(map, "id", "");
                    switch (prj) {
                        case "B5FA42944566A83F89A1505807075001":
                            map.put("desc", system.getLearnNote());
                            break;
                        case "B5FA42944566A83F89A1505807075002":
                            map.put("desc", system.getOrgLearNote());
                            break;
                        case "B5FA42944566A83F89A1505807075003":
                            map.put("desc", system.getImpFileNote());
                            break;
                        case "B5FA42944566A83F89A1505807075004":
                            map.put("desc", system.getImpPdcNote());
                            break;
                        case "B5FA42944566A83F89A1505807075005":
                            map.put("desc", system.getImpAckNote());
                            break;
                        case "B5FA42944566A83F89A1505807075006":
                            map.put("desc", system.getImpPblmNote());
                            break;
                        case "B5FA42944566A83F89A1505807075007":
                            map.put("desc", system.getImpOtherNote());
                            break;
                        case "B5FA42944566A83F89A1505807075008":
                            map.put("desc", system.getImpLeadNote());
                            break;
                        case "B5FA42944566A83F89A1505807075009":
                            map.put("desc", safety.getSafeGuidNote());
                            break;
                        case "B5FA42944566A83F89A1505807075010":
                            map.put("desc", safety.getMakLevNote());
                            break;
                        case "B5FA42944566A83F89A1505807075011":
                            map.put("desc", safety.getMakKeyNote());
                            break;
                        case "B5FA42944566A83F89A1505807075012":
                            map.put("desc", safety.getMakMwrNote());
                            break;
                        case "B5FA42944566A83F89A1505807075013":
                            map.put("desc", safety.getMakBookNote());
                            break;
                        case "B5FA42944566A83F89A1505807075014":
                            map.put("desc", safety.getManListNote());
                            break;
                        case "B5FA42944566A83F89A1505807075015":
                            map.put("desc", safety.getMakPlanNote());
                            break;
                        case "B5FA42944566A83F89A1505807075016":
                            map.put("desc", safety.getPlanActNote());
                            break;
                        case "B5FA42944566A83F89A1505807075017":
                            map.put("desc", safety.getDrvRunNote());
                            break;
                        case "B5FA42944566A83F89A1505807075018":
                            map.put("desc", safety.getMakSysNote());
                            break;
                        case "B5FA42944566A83F89A1505807075019":
                            map.put("desc", safety.getMakDbNote());
                            break;
                        case "B5FA42944566A83F89A1505807075020":
                            map.put("desc", safety.getActItNote());
                            break;
                        case "B5FA42944566A83F89A1505807075021":
                            map.put("desc", safety.getNactPhnNote());
                            break;
                        case "B5FA42944566A83F89A1505807075022":
                            map.put("desc", safety.getActPblmNote());
                            break;
                        default:
                    }
                }

                if ("9".equals(MapUtils.getString(map, "seq"))) {
                    if ("水利安全生产信息系统使用情况".equals(MapUtils.getString(map, "prj"))) {
                        map.put("desc", it.getSysUsrNote());
                    }
                    if ("水利安全生产信息系统用户启用情况，包括用户总量、未启用数量和未启用原因等情况".equals(MapUtils.getString(map, "prj"))) {
                        map.put("desc", it.getSysAbleNote());
                    }
                    if ("安全生产信息化建设存在的问题和下一步推进措施".equals(MapUtils.getString(map, "prj"))) {
                        map.put("desc", it.getSysSug());
                    }
                }
            }

            result.put("pblms", mapList);
            String duchaImage = "";
            String beijianchaImage = "";
            List<GwComFile> ducha = gwComFileService.findList(Builder.of(GwComFileParam::new).with(GwComFileParam::setBizId, r.getId() + orgId).with(GwComFileParam::setBizType, "signatureYndepLeader").build());
            if (ducha != null && ducha.size() > 0) {
                duchaImage = ducha.get(0).getFilePath();
            }

            List<GwComFile> beijiancha = gwComFileService.findList(Builder.of(GwComFileParam::new).with(GwComFileParam::setBizId, r.getId() + orgId).with(GwComFileParam::setBizType, "signatureYndepUnit").build());
            if (beijiancha != null && beijiancha.size() > 0) {
                beijianchaImage = beijiancha.get(0).getFilePath();
            }

            result.put("ducha", duchaImage);
            result.put("beijiancha", beijianchaImage);

            logger.info("ducha img path" + duchaImage);
            logger.info("beijiancha img path" + beijianchaImage);
        });
        return result;
    }

    /**
     * 设置恰当位置的setRowSpan属性
     *
     * @param indexs         不加单元格的索引集合
     * @param spanStartIndex 要加的单元格开始索引集合
     * @param spanNumList    要加的单元格合并的值集合
     * @param table          table
     * @param cell           cell
     * @param i              索引
     */
    private void setRowsSpan(List<Integer> indexs, List<Integer> spanStartIndex,
                             List<Integer> spanNumList, PdfPTable table, PdfPCell cell, int i) {
        if (indexs != null) {
            boolean isAllNotEqual = true;
            for (Integer index : indexs) {
                if (i == index) {
                    isAllNotEqual = false;
                    break;
                }
            }

            //没有不加的下标
            if (isAllNotEqual) {
                // 判断在哪里设置span值
                if (spanStartIndex != null) {
                    boolean isSpan = false;
                    int copyJ = 0;
                    for (int j = 0; j < spanStartIndex.size(); j++) {
                        if (i == spanStartIndex.get(j)) {
                            isSpan = true;
                            copyJ = j;
                            break;
                        }
                    }
                    if (isSpan) {
                        int spanNum = spanNumList.get(copyJ);
                        cell.setRowspan(spanNum);
                    }
                }
                table.addCell(cell);
            }
        } else {
            table.addCell(cell);
        }
    }

    /**
     * 获取某列要合并的单元格数量
     *
     * @param list 内容必须符合'A,A,B,C,D,D,D,E' 而不是 'A,A,B,C,A,D,D,D,E' ，即所有相同的值必须在一起不能分散
     * @return
     */
    private List<Integer> getSpanNumList(List<String> list) {

        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        if (list.size() > 0) {
            for (int i = 0; i < list.size(); i = i + 1) {
                map.put(list.get(i), i);
            }
        }

        //修改对应key值的value
        Set<String> s = map.keySet();//获取KEY集合
        List<String> strings = new ArrayList<>(s);
        int spanNum = 0;
        for (String string : strings) {
            int tmpSpanNum = map.get(string) - spanNum + 1;
            map.put(string, tmpSpanNum);
            spanNum += tmpSpanNum;
        }

        List<Integer> res = new ArrayList<>();
        for (String string : strings) {
            res.add(map.get(string));
        }
        return res;
    }

    /**
     * 获取某列要合并的单元格初始下标
     *
     * @param list           内容必须符合'A,A,B,C,D,D,D,E' 而不是 'A,A,B,C,A,D,D,D,E' ，即所有相同的值必须在一起不能分散
     * @param resSpanNumList
     * @return
     */
    private List<Integer> getStartIndexList(List<String> list, List<Integer> resSpanNumList) {

        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        if (list.size() > 0) {
            for (int i = 0; i < list.size(); i = i + 1) {
                map.put(list.get(i), i);
            }
        }

        Set<String> keys = map.keySet();//获取KEY集合
        List<String> stringKeys = new ArrayList<>(keys);

        List<Integer> res = new ArrayList<>();
        if (stringKeys.size() == resSpanNumList.size()) {
            for (int i = 0; i < stringKeys.size(); i++) {
                res.add(map.get(stringKeys.get(i)) - resSpanNumList.get(i) + 1);
            }
        }
        return res;
    }

    /**
     * 不加某字段的索引集合
     *
     * @param listLength
     * @param resSpanNumList
     * @param resStartIndexList
     * @return
     */
    private List<Integer> getIndexs(int listLength,
                                    List<Integer> resSpanNumList, List<Integer> resStartIndexList) {
        List<Integer> indexs = new ArrayList<>();
        for (int i = 0; i < listLength; i++) {
            for (int j = 0; j < resStartIndexList.size(); j++) {
                if (i == resStartIndexList.get(j)) {
                    for (int k = i + 1; k < i + resSpanNumList.get(j); k++) {
                        indexs.add(k);
                    }
                }
            }
        }
        return indexs;
    }


}