fj-dc/.svn/pristine/d0/d07c15a6255bbb93ea4a2745b1ff77ed2dbc4ac9.svn-base

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

import cn.com.goldenwater.core.service.AbstractCrudService;
import cn.com.goldenwater.dcproj.constValue.BisInspEnum;
import cn.com.goldenwater.dcproj.constValue.RsvrEnum;
import cn.com.goldenwater.dcproj.constValue.SplitValue;
import cn.com.goldenwater.dcproj.constValue.StateEnum;
import cn.com.goldenwater.dcproj.constValue.StatusEnum;
import cn.com.goldenwater.dcproj.dao.AttRsBaseCrrctDao;
import cn.com.goldenwater.dcproj.dao.AttRsBaseDao;
import cn.com.goldenwater.dcproj.dao.BisInspAllObjDao;
import cn.com.goldenwater.dcproj.dao.BisInspBaseExtDao;
import cn.com.goldenwater.dcproj.dao.BisInspBasePresExtDao;
import cn.com.goldenwater.dcproj.dao.BisInspBaseViewDao;
import cn.com.goldenwater.dcproj.dao.BisInspPblmDao;
import cn.com.goldenwater.dcproj.dao.BisInspPblmPlistDao;
import cn.com.goldenwater.dcproj.dao.BisInspPreListDao;
import cn.com.goldenwater.dcproj.dao.BisInspRsvrBenefitsDao;
import cn.com.goldenwater.dcproj.dao.BisInspRsvrProjectDao;
import cn.com.goldenwater.dcproj.dao.BisInspRsvrRgstrDao;
import cn.com.goldenwater.dcproj.dao.BisInspSafeExtManageDao;
import cn.com.goldenwater.dcproj.dao.GwComFileDao;
import cn.com.goldenwater.dcproj.dto.BisInspRsvrRgstrPcDto;
import cn.com.goldenwater.dcproj.dto.BisInspTaskTotal;
import cn.com.goldenwater.dcproj.model.AttRsBase;
import cn.com.goldenwater.dcproj.model.BisInspAllObj;
import cn.com.goldenwater.dcproj.model.BisInspBaseExt;
import cn.com.goldenwater.dcproj.model.BisInspBasePresExt;
import cn.com.goldenwater.dcproj.model.BisInspBaseView;
import cn.com.goldenwater.dcproj.model.BisInspPblm;
import cn.com.goldenwater.dcproj.model.BisInspPblmPlist;
import cn.com.goldenwater.dcproj.model.BisInspPblmPlistFormDTO;
import cn.com.goldenwater.dcproj.model.BisInspPreList;
import cn.com.goldenwater.dcproj.model.BisInspRsvrBenefits;
import cn.com.goldenwater.dcproj.model.BisInspRsvrPblmMend;
import cn.com.goldenwater.dcproj.model.BisInspRsvrProject;
import cn.com.goldenwater.dcproj.model.BisInspRsvrRgstr;
import cn.com.goldenwater.dcproj.model.BisInspRsvrRgstrData;
import cn.com.goldenwater.dcproj.model.BisInspRsvrRgstrDto;
import cn.com.goldenwater.dcproj.model.BisInspSafeExtManage;
import cn.com.goldenwater.dcproj.model.GwComFile;
import cn.com.goldenwater.dcproj.param.AttRsBaseCrrctParam;
import cn.com.goldenwater.dcproj.param.AttRsBaseParam;
import cn.com.goldenwater.dcproj.param.BisInspAllObjParam;
import cn.com.goldenwater.dcproj.param.BisInspBaseExtParam;
import cn.com.goldenwater.dcproj.param.BisInspBasePresExtParam;
import cn.com.goldenwater.dcproj.param.BisInspBaseViewParam;
import cn.com.goldenwater.dcproj.param.BisInspPblmParam;
import cn.com.goldenwater.dcproj.param.BisInspPblmPlistParam;
import cn.com.goldenwater.dcproj.param.BisInspPreListParam;
import cn.com.goldenwater.dcproj.param.BisInspPresSafeParam;
import cn.com.goldenwater.dcproj.param.BisInspRsvrBenefitsParam;
import cn.com.goldenwater.dcproj.param.BisInspRsvrPblmMendParam;
import cn.com.goldenwater.dcproj.param.BisInspRsvrProjectParam;
import cn.com.goldenwater.dcproj.param.BisInspRsvrRgstrParam;
import cn.com.goldenwater.dcproj.param.BisInspSafeExtManageParam;
import cn.com.goldenwater.dcproj.param.BisInspVo;
import cn.com.goldenwater.dcproj.param.TypeParam;
import cn.com.goldenwater.dcproj.service.BisInspObjStrategy;
import cn.com.goldenwater.dcproj.service.BisInspPblmPlistFormService;
import cn.com.goldenwater.dcproj.service.BisInspPblmPlistService;
import cn.com.goldenwater.dcproj.service.BisInspPblmService;
import cn.com.goldenwater.dcproj.service.BisInspPresSafeService;
import cn.com.goldenwater.dcproj.service.BisInspRsvrPblmMendService;
import cn.com.goldenwater.dcproj.service.BisInspRsvrRgstrService;
import cn.com.goldenwater.dcproj.service.OlBisInspOrgService;
import cn.com.goldenwater.dcproj.utils.AdLevelUtil;
import cn.com.goldenwater.dcproj.utils.Builder;
import cn.com.goldenwater.dcproj.utils.DateUtils;
import cn.com.goldenwater.dcproj.utils.InspUtils;
import cn.com.goldenwater.dcproj.utils.http.HikvisionOpenApiUtil;
import cn.com.goldenwater.id.util.UuidUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;


/**
 * @author lune
 * @date 2019-2-18
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class BisInspRsvrRgstrServiceImpl extends AbstractCrudService<BisInspRsvrRgstr, BisInspRsvrRgstrParam> implements BisInspRsvrRgstrService, BisInspObjStrategy {

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

    @Autowired
    private BisInspRsvrRgstrDao bisInspRsvrRgstrDao;

    @Autowired
    private BisInspBaseExtDao bisInspBaseExtDao;
    @Autowired
    private BisInspAllObjDao bisInspAllObjDao;
    @Autowired
    private AttRsBaseCrrctDao attRsBaseCrrctDao;

    @Autowired
    private BisInspSafeExtManageDao bisInspSafeExtManageDao;

    @Autowired
    private BisInspPreListDao bisInspPreListDao;

    @Autowired
    private BisInspBaseViewDao bisInspBaseViewDao;

    @Autowired
    private BisInspBasePresExtDao bisInspBasePresExtDao;

    @Autowired
    private BisInspPblmDao bisInspPblmDao;
    @Autowired
    private BisInspPblmPlistDao bisInspPblmPlistDao;
    @Autowired
    private GwComFileDao comFileDao;
    @Autowired
    private BisInspRsvrBenefitsDao bisInspRsvrBenefitsDao;
    @Autowired
    private BisInspRsvrProjectDao bisInspRsvrProjectDao;

    @Autowired
    private BisInspPresSafeService bisInspPresSafeService;

    @Autowired
    private BisInspRsvrPblmMendService bisInspRsvrPblmMendService;
    @Autowired
    private BisInspPblmService bisInspPblmService;

    @Autowired
    private OlBisInspOrgService olBisInspOrgService;

    @Autowired
    private BisInspPblmPlistService bisInspPblmPlistService;

    @Autowired
    private BisInspPblmPlistFormService formService;

    public BisInspRsvrRgstrServiceImpl(BisInspRsvrRgstrDao bisInspRsvrRgstrDao) {
        super(bisInspRsvrRgstrDao);
        this.bisInspRsvrRgstrDao = bisInspRsvrRgstrDao;
    }

    @Override
    public int update(BisInspRsvrRgstr entity) {
        entity.setUptm(new Date());
        String persId = entity.getPersId();
        entity.setPersId(null);
        String curOrgId = entity.getOrgId();
        entity.setOrgId(null);
        String curProvince = entity.getProvince();
        entity.setProvince(null);
        int ret = super.update(entity);
        updatePblmState(entity);
        //根据所属省份
        if (StringUtils.isNotBlank(curProvince) && curProvince.startsWith("5100")) {
            // 四川省 水库问题填完之后  提交 直接添加到台账，并启动
            autoStartTask(entity, persId, curOrgId, olBisInspOrgService.getDefaultOrg(curOrgId).getOrgNm(), curProvince);
        }
        return ret;
    }

    private int autoStartTask(BisInspRsvrRgstr entity, String persId, String curOrgId, String curOrgNm, String curProvince) {
        int res = -1;
        // 第一步根据 水库登记表ID  rgstrId 获取到问题列表
        String rgstrId = entity.getRgstrId();
        BisInspVo bisInspVo = new BisInspVo();
        bisInspVo.setRegid(rgstrId);
        List<BisInspVo> pblms = bisInspPblmDao.pblmPage(bisInspVo);
        // 督查类型为 水库
        if (null != pblms && pblms.size() > 0 && "1".equals(pblms.get(0).getObjType())) {
            for (BisInspVo v : pblms) {
                if (v.getAdFullName() != null) {
                    if (v.getAdFullName().contains(SplitValue.HENG_SPLIT)) {
                        String[] split = v.getAdFullName().split(SplitValue.HENG_SPLIT);
                        if (split.length == 3) {
                            v.setProvince(split[0]);
                            v.setCity(split[1]);
                            v.setCountry(split[2]);
                        }
                        if (split.length == 2) {
                            v.setProvince(split[0]);
                            v.setCity(split[1]);
                            v.setCountry("");
                        }
                    } else {
                        v.setProvince(v.getAdFullName());
                    }
                    try {
                        // 第二步把问题列表 添加到整改待办表 plist 没有添加的添加，添加过未启动的更新 添加过已启动的跳过
                        BisInspPblmPlist bisInspPblmPlist = new BisInspPblmPlist();
                        bisInspPblmPlist.setPblmId(v.getPblmId());
                        bisInspPblmPlist.setProvince(v.getProvince());
                        bisInspPblmPlist.setCity(v.getCity());
                        bisInspPblmPlist.setCounty(v.getCountry());
                        Date pblmTm = DateUtils.Str2Date(v.getInspPblmTm(), "yyyy-MM-dd");
                        bisInspPblmPlist.setPblmTm(pblmTm);
                        bisInspPblmPlist.setPblmNameBz(v.getPblmNameBz());
                        bisInspPblmPlist.setCheckPointBz(v.getCheckPointBz());
                        bisInspPblmPlist.setPblmDescBz(v.getPblmDescBz());
                        bisInspPblmPlist.setInspPblmCate(v.getInspPblmCate());
                        bisInspPblmPlist.setInspPblmDesc(v.getInspPblmDesc());
                        bisInspPblmPlist.setPblmClassify("小型水库");
                        bisInspPblmPlist.setObjType(v.getObjType());
                        bisInspPblmPlist.setObjName(v.getObjName());
                        bisInspPblmPlist.setPersId(persId);
                        // 大坝注册登记号
                        bisInspPblmPlist.setDamRegCode(v.getDamRegCode());
                        // 根据
                        BisInspPblmPlistParam pblmPlistParam = new BisInspPblmPlistParam();
                        pblmPlistParam.setPblmId(v.getPblmId());
                        // 未删除
                        pblmPlistParam.setDataStat("0");
                        List<BisInspPblmPlist> pblmPlists = bisInspPblmPlistService.findList(pblmPlistParam);
                        if (null == pblmPlists || 0 == pblmPlists.size()) {
                            // 根据问题id没有在整改信息表中找到记录 认为是新增
                            bisInspPblmPlist.setSendOrgId(curOrgId);
                            bisInspPblmPlist.setSendOrgName(curOrgNm);
                            bisInspPblmPlistService.insert(bisInspPblmPlist);
                        } else {
                            // 如果仅有1条就 判断是否启动 是否处理 是否销号 "0"
                            BisInspPblmPlist pblmPlist = pblmPlists.get(0);
                            if (1 == pblmPlists.size() && "0".equals(pblmPlist.getIsStart()) && "0".equals(pblmPlist.getPblmState()) && "0".equals(pblmPlist.getPblmOut())) {
                                // 有且仅有1条整改记录且未处理，未销号，没有启动
                                bisInspPblmPlist.setId(pblmPlists.get(0).getId());
                                bisInspPblmPlistService.update(bisInspPblmPlist);
                            }
                        }
                        BisInspPblmPlist finalPblmPlist = bisInspPblmPlistService.get(bisInspPblmPlist.getId());
                        logger.info("finalPblmPlist:" + finalPblmPlist.toString());

                        if (null != finalPblmPlist && "0".equals(finalPblmPlist.getIsStart()) && "0".equals(finalPblmPlist.getPblmOut()) && "0".equals(finalPblmPlist.getPblmState())) {
                            // 第三步把添加的和更新的问题启动
                            BisInspPblmPlistFormDTO pblmPlistFormDTO = new BisInspPblmPlistFormDTO();
                            if (finalPblmPlist.getPblmAdName().contains(SplitValue.HENG_SPLIT)) {
                                String[] split = bisInspPblmPlist.getPblmAdName().split(SplitValue.HENG_SPLIT);
                                if (split.length == 3) {
                                    bisInspPblmPlist.setProvince(split[0]);
                                    bisInspPblmPlist.setCity(split[1]);
                                    bisInspPblmPlist.setCounty(split[2]);
                                }
                                if (split.length == 2) {
                                    bisInspPblmPlist.setProvince(split[0]);
                                    bisInspPblmPlist.setCity(split[1]);

                                }
                                if (split.length == 1) {
                                    bisInspPblmPlist.setProvince(split[0]);
                                    bisInspPblmPlist.setCity("");
                                }
                            }
                            pblmPlistFormDTO.setPblmPlist(finalPblmPlist);
                            //启动工作流前名称
                            logger.info("提交问题启动工作流前：" + pblmPlistFormDTO.getPblmPlist().toString());
                            // q启动流程 固定人员 向虹宇  ac338ab4785546708826bbf00cc57e17
                            formService.saveFormsAndStartFlow(pblmPlistFormDTO, "ac338ab4785546708826bbf00cc57e17", curOrgId, curProvince);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        logger.error(e.getMessage());
                    }
                }
            }
        }
        return res;
    }

    private void updatePblmState(BisInspRsvrRgstr rgstr) {
        BisInspRsvrRgstr r = get(rgstr.getRgstrId());
        if (r == null) {
            return;
        }
        logger.info("BisInspRsvrRgstr:" + r.toString());
        bisInspPblmService.updateStateByObjId(r.getObjId(), rgstr.getState());
    }

    @Override
    public BisInspRsvrRgstr getBy(BisInspRsvrRgstrParam param) {
        BisInspRsvrRgstr rgstr = super.getBy(param);
        if (rgstr != null && !"2".equals(rgstr.getRectStat())) {
            checkFinished(rgstr);
        }
        return rgstr;
    }

    @Override
    public BisInspRsvrRgstr get(String key) {
        BisInspRsvrRgstr rgstr = super.get(key);
        if (rgstr == null) {
            return rgstr;
        }
        if (!"2".equals(rgstr.getRectStat())) {
            checkFinished(rgstr);
        }
        return rgstr;
    }


    /**
     * 更新整改问题状态
     * 判断问题是否全部整改
     *
     * @param rgstr
     */
    private void checkFinished(BisInspRsvrRgstr rgstr) {
        String rectStat = "0";
        List<BisInspRsvrPblmMend> pblmMendList = bisInspRsvrPblmMendService.findList(Builder.of(BisInspRsvrPblmMendParam::new).with(BisInspRsvrPblmMendParam::setRsCode, rgstr.getRsCode()).build());
        if (pblmMendList == null || pblmMendList.size() == 0) {
            rectStat = "2";
        } else {
            long total = pblmMendList.size();
            long revw = pblmMendList.stream().filter(p -> "2".equals(p.getRevwState())).count();

            if (total == revw) {
                rectStat = "2";
            } else if (total > revw && revw != 0) {
                rectStat = "1";
            }
        }

        if (!rectStat.equals(rgstr.getRectStat())) {
            rgstr.setRectStat(rectStat);
            bisInspRsvrRgstrDao.update(rgstr);
        }
    }

    @Override
    public void insertObj(BisInspAllObj bisInspAllObj, String persId) {
        AttRsBaseParam baseParam = new AttRsBaseParam();
        baseParam.setRsCode(bisInspAllObj.getCode());
        AttRsBase attRsBase = attRsBaseDao.getBy(baseParam);
        BisInspRsvrRgstr b = new BisInspRsvrRgstr();
        BeanUtils.copyProperties(attRsBase, b);
        String registrId = UUID.randomUUID().toString().replace(SplitValue.HENG_SPLIT, "");
        b.setRgstrId(registrId);
        b.setObjId(bisInspAllObj.getObjId());
        b.setRsvrNm(bisInspAllObj.getNm());
        b.setOrgId(bisInspAllObj.getOrgId());
        b.setAdCode(attRsBase.getAdmDiv());
        b.setRsvrAdmName(attRsBase.getRsAdmName());
        if (attRsBase.getRegNo() != null) {
            b.setDamRegCode(attRsBase.getRegCode());
        }
        if (attRsBase.getDamSizeHig() == null) {
            b.setDamMaxHigh(null);
        } else {
            b.setDamMaxHigh(Double.toString(attRsBase.getDamSizeHig()));
        }
//        if (StringUtils.isNotBlank(attRsBase.getLocation())) {
//            b.setHystSite(attRsBase.getLocation());
//        } else {
//            b.setHystSite(attRsBase.getRsLoc());
//        }
        b.setHystSite(attRsBase.getRsLoc());
        if (attRsBase.getCenterYGd() != null) {
            b.setRsvrLat(Double.parseDouble(attRsBase.getCenterYGd()));
        }
        if (attRsBase.getCenterXGd() != null) {
            b.setRsvrLong(Double.parseDouble(attRsBase.getCenterXGd()));
        }
        b.setResCreateTime(attRsBase.getCompDate());
        b.setDamRegCode(attRsBase.getRegCode());
        b.setHasDamRegCode("1");

        b.setState(StateEnum.NOWASTSTATE.getKey());
        b.setPresStat(StateEnum.NOWASTSTATE.getKey());
        b.setBaseStat(StateEnum.NOWASTSTATE.getKey());
        b.setResRunStat(StateEnum.NOWASTSTATE.getKey());
        b.setViewStat(StateEnum.NOWASTSTATE.getKey());
        b.setDataStat(StateEnum.NOWASTSTATE.getKey());
        b.setSafeStat(StateEnum.NOWASTSTATE.getKey());
        Date date = new Date();
        b.setIntm(date);
        b.setUptm(date);
        bisInspRsvrRgstrDao.insert(b);
    }

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

    @Override
    public void cleanObjData(String objId) {
        BisInspRsvrRgstrParam bisInspRsvrRgstrParam = new BisInspRsvrRgstrParam();
        bisInspRsvrRgstrParam.setObjId(objId);
        List<BisInspRsvrRgstr> list = this.bisInspRsvrRgstrDao.findList(bisInspRsvrRgstrParam);
        if (list.size() > 0) {
            String id = list.get(0).getRgstrId();
            BisInspBaseViewParam p = new BisInspBaseViewParam();
            p.setRgstrId(id);
            //获取走访情况
            BisInspBaseView bisInspBaseView = this.bisInspBaseViewDao.getBy(p);
            if (bisInspBaseView != null) {
                //删除走访人员情况
                this.bisInspPreListDao.deleteByViewId(bisInspBaseView.getViewId());
            }
            this.bisInspBaseViewDao.deleteBy(p);//删除水库走访情况

            BisInspSafeExtManageParam bisInspSafeExtManageParam = new BisInspSafeExtManageParam();
            bisInspSafeExtManageParam.setRgstrId(id);
            this.bisInspSafeExtManageDao.deleteBy(bisInspSafeExtManageParam);//删除水库安全运行管理情况
            BisInspBaseExtParam bisInspBaseExtParam = new BisInspBaseExtParam();
            bisInspBaseExtParam.setRgstrId(id);
            this.bisInspBaseExtDao.deleteBy(bisInspBaseExtParam);//删除水库“三项基本要求”落实情况
            BisInspBasePresExtParam bisInspBasePresExt = new BisInspBasePresExtParam();
            bisInspBasePresExt.setRgstrId(id);
            this.bisInspBasePresExtDao.deleteBy(bisInspBasePresExt);//删除水库“三个责任人”落实情况

            BisInspRsvrProjectParam bisInspRsvrProjectParam = new BisInspRsvrProjectParam();//水库工程实体情况
            bisInspRsvrProjectParam.setRgstrId(id);
            bisInspRsvrProjectDao.deleteBy(bisInspRsvrProjectParam);
            BisInspRsvrBenefitsParam bisInspRsvrBenefitsParam = new BisInspRsvrBenefitsParam();//水库效益发挥情况
            bisInspRsvrBenefitsParam.setRgstrId(id);
            bisInspRsvrBenefitsDao.deleteBy(bisInspRsvrBenefitsParam);
            // 水库安全管理三级责任人填录状态（青海）
            this.bisInspPresSafeService.deleteBy(Builder.of(BisInspPresSafeParam::new)
                    .with(BisInspPresSafeParam::setRgstrId, id).build());
            BisInspRsvrRgstr bisInspRsvrRgstr = this.bisInspRsvrRgstrDao.get(id);
            this.bisInspRsvrRgstrDao.delete(id);//删除水库登记表
            if (bisInspRsvrRgstr != null) {
                BisInspAllObjParam bisInspAllObjParam = new BisInspAllObjParam();
                bisInspAllObjParam.setObjId(objId);
                this.bisInspAllObjDao.deleteBy(bisInspAllObjParam);//删除督查对象
//                bisInspAllObjDao.delete(bisInspRsvrRgstr.getObjId());//删除对象名录表
                AttRsBaseCrrctParam attRsBaseCrrctParam = new AttRsBaseCrrctParam();
                attRsBaseCrrctParam.setObjId(bisInspRsvrRgstr.getObjId());
                attRsBaseCrrctDao.deleteBy(attRsBaseCrrctParam);
            }
        }
    }

    @Override
    public PageInfo findObjPageByType(TypeParam typeParam, HttpServletResponse response) {
        return this.findPageByType(typeParam);
    }

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

    @Override
    public BisInspRsvrRgstr createCheckData(BisInspRsvrRgstr rsvrRgstr, String flag, String currentPersId) {
        String regstrId = rsvrRgstr.getRgstrId();
        String regstrId_flag = regstrId + "_" + flag;
        BisInspRsvrProjectParam rsvrProjectParam = new BisInspRsvrProjectParam();
        rsvrProjectParam.setRgstrId(regstrId);
        BisInspRsvrProject rsvrProject = bisInspRsvrProjectDao.getBy(rsvrProjectParam);
        if (rsvrProject != null) {
            rsvrProject.setRgstrId(regstrId_flag);
            rsvrProject.setId(UuidUtil.uuid());
            rsvrProject.setStatus(flag);
            bisInspRsvrProjectDao.insert(rsvrProject);
            rsvrRgstr.setReverStat(flag);
        }
        BisInspRsvrBenefitsParam benefitsParam = new BisInspRsvrBenefitsParam();
        benefitsParam.setRgstrId(regstrId);
        BisInspRsvrBenefits rsvrBenefits = bisInspRsvrBenefitsDao.getBy(benefitsParam);
        if (rsvrBenefits != null) {
            rsvrBenefits.setRgstrId(regstrId_flag);
            rsvrBenefits.setId(UuidUtil.uuid());
            rsvrBenefits.setStatus(flag);
            bisInspRsvrBenefitsDao.insert(rsvrBenefits);
            rsvrRgstr.setBenefitStat(flag);
        }
        BisInspBaseViewParam baseViewParam = new BisInspBaseViewParam();
        baseViewParam.setRgstrId(regstrId);
        BisInspBaseView inspBaseView = bisInspBaseViewDao.getBy(baseViewParam);
        if (inspBaseView != null) {
            String newViewId = UuidUtil.uuid();
            inspBaseView.setViewId(newViewId);
            inspBaseView.setRgstrId(regstrId_flag);
            inspBaseView.setStatus(flag);
            String viewId = inspBaseView.getViewId();
            bisInspBaseViewDao.insert(inspBaseView);
            BisInspPreListParam preListParam = new BisInspPreListParam();
            preListParam.setViewId(viewId);
            List<BisInspPreList> inspPreLists = bisInspPreListDao.findList(preListParam);
            if (inspPreLists != null && !inspPreLists.isEmpty()) {
                for (BisInspPreList inspPreList : inspPreLists) {
                    inspPreList.setViewPreId(UuidUtil.uuid());
                    inspPreList.setViewId(newViewId);
                    bisInspPreListDao.insert(inspPreList);
                }
            }
            rsvrRgstr.setViewStat(flag);
        }

        BisInspPblmParam pblmParam = new BisInspPblmParam();
        pblmParam.setRegid(regstrId);
        List<BisInspPblm> pblmList = bisInspPblmDao.findList(pblmParam);
        if (pblmList != null && !pblmList.isEmpty()) {
            for (BisInspPblm inspPblm : pblmList) {
                List<GwComFile> comFiles = comFileDao.findFileByBiz(inspPblm.getPblmId());
                String pblmId = UuidUtil.uuid();
                inspPblm.setPblmId(pblmId);
                inspPblm.setDataStat(flag);
                inspPblm.setRegid(regstrId_flag);
                if (comFiles != null && !comFiles.isEmpty()) {
                    for (GwComFile comFile : comFiles) {
                        comFile.setBizId(pblmId);
                        comFile.setId(UuidUtil.uuid());
                        comFileDao.insert(comFile);
                    }
                }
                bisInspPblmDao.insert(inspPblm);
            }
        }
        BisInspBasePresExtParam basePresExtParam = new BisInspBasePresExtParam();
        basePresExtParam.setRgstrId(regstrId);
        BisInspBasePresExt basePresExt = bisInspBasePresExtDao.getBy(basePresExtParam);
        if (basePresExt != null) {
            basePresExt.setDutyId(UuidUtil.uuid());
            basePresExt.setRgstrId(regstrId_flag);
            basePresExt.setStatus(flag);
            bisInspBasePresExtDao.insert(basePresExt);
            rsvrRgstr.setPresStat(flag);
        }
        BisInspBaseExtParam bisInspBaseExtParam = new BisInspBaseExtParam();
        bisInspBaseExtParam.setRgstrId(regstrId);
        BisInspBaseExt inspBaseExt = bisInspBaseExtDao.getBy(bisInspBaseExtParam);
        if (inspBaseExt != null) {
            inspBaseExt.setRgstrId(regstrId_flag);
            inspBaseExt.setThrqId(UuidUtil.uuid());
            inspBaseExt.setStatus(flag);
            bisInspBaseExtDao.insert(inspBaseExt);
            rsvrRgstr.setBaseStat(flag);
        }
        BisInspSafeExtManageParam safeExtManageParam = new BisInspSafeExtManageParam();
        safeExtManageParam.setRgstrId(regstrId);
        BisInspSafeExtManage safeExtManage = bisInspSafeExtManageDao.getBy(safeExtManageParam);
        if (safeExtManage != null) {
            safeExtManage.setMngrnId(UuidUtil.uuid());
            safeExtManage.setRgstrId(regstrId_flag);
            safeExtManage.setStatus(flag);
            bisInspSafeExtManageDao.insert(safeExtManage);
            rsvrRgstr.setResRunStat(flag);
        }
        rsvrRgstr.setState(flag);
        return rsvrRgstr;
    }

    /**
     * 根据行政 开始时间和结束时间统计小水库 督查对象的列表数据
     *
     * @param adCode
     * @param stTm
     * @param enTm
     * @return
     */
    @Override
    public BisInspTaskTotal getListByTm(String adCode, Date stTm, Date enTm) {
        return bisInspRsvrRgstrDao.getListByTm(adCode, stTm, enTm);
    }


    @Override
    public void updateRsvr(String rgstrId, String status, String input) {
        if (StringUtils.isBlank(rgstrId)) {
            return;
        }
        BisInspRsvrRgstr inspRsvrRgstr = bisInspRsvrRgstrDao.get(rgstrId);
        if (StringUtils.isBlank(status)) {
            status = "2";
        }
        RsvrEnum rsvrEnum = RsvrEnum.getByValue(input);
        if (rsvrEnum == null) {
            return;
        }
        switch (rsvrEnum) {
            case PERSSAFE:
                inspRsvrRgstr.setSafeStat(status);
                break;
            case REIN:
                inspRsvrRgstr.setReinStat(status);
                break;
            case DAM:
                inspRsvrRgstr.setDamStat(status);
                break;
            case FITS:
                inspRsvrRgstr.setBenefitStat(status);
                break;
            case PROJECT:
                inspRsvrRgstr.setReverStat(status);
                break;
            case PRES:
                inspRsvrRgstr.setPresStat(status);
                break;
            case VIEW:
                inspRsvrRgstr.setViewStat("2");
                break;
            case EXT:
                inspRsvrRgstr.setBaseStat(status);
                break;
            case SAFE:
                inspRsvrRgstr.setResRunStat(status);
                break;
            default:
        }

        if (StringUtils.isBlank(inspRsvrRgstr.getState()) ||
                StateEnum.NOWASTSTATE.getKey().equals(inspRsvrRgstr.getState())) {
            inspRsvrRgstr.setState(StateEnum.EXWASTSTATE.getKey());
        } else {
            inspRsvrRgstr.setState(inspRsvrRgstr.getState());
        }

        bisInspRsvrRgstrDao.update(inspRsvrRgstr);
    }


    @Override
    public int deleteRsvrRgstr(String id) {

        return bisInspRsvrRgstrDao.deleteInFlag(id);

    }

    @Override
    public int add(BisInspRsvrRgstrData bisInspRsvrRgstrData) {
        Date date = new Date();
        BisInspRsvrRgstr bisInspRsvrRgstr = bisInspRsvrRgstrData.getRsvrRgstr();
        bisInspRsvrRgstr.setState(StateEnum.EXWASTSTATE.getKey());
        bisInspRsvrRgstr.setDataStat("0");
        bisInspRsvrRgstr.setUptm(date);
        bisInspRsvrRgstr.setIntm(date);

        BisInspBaseExt baseExt = bisInspRsvrRgstrData.getBaseExt();
        baseExt.setUpdateTime(date);
        baseExt.setCreateTime(date);
        baseExt.setStatus(StatusEnum.START.getStatus());
        baseExt.setThrqId(UuidUtil.uuid());
        baseExt.setRgstrId(bisInspRsvrRgstr.getRgstrId());

        BisInspBaseView baseView = bisInspRsvrRgstrData.getBaseView();
        baseView.setRgstrId(bisInspRsvrRgstr.getRgstrId());
        baseView.setViewId(UuidUtil.uuid());
        baseView.setUpdateTime(date);
        baseView.setUpdateTime(date);

        BisInspSafeExtManage safeExtManage = bisInspRsvrRgstrData.getSafeExtManage();
        safeExtManage.setUpdateTime(date);
        safeExtManage.setCreateTime(date);
        safeExtManage.setMngrnId(UuidUtil.uuid());
        safeExtManage.setRgstrId(bisInspRsvrRgstr.getRgstrId());
        safeExtManage.setStatus(StatusEnum.START.getStatus());

        BisInspBasePresExt basePresExt = bisInspRsvrRgstrData.getBasePresExt();
        basePresExt.setUpdateTime(date);
        basePresExt.setCreateTime(date);
        basePresExt.setDutyId(UuidUtil.uuid());
        basePresExt.setRgstrId(bisInspRsvrRgstr.getRgstrId());
        basePresExt.setStatus(StatusEnum.START.getStatus());
        InspUtils.addPreList(baseView, bisInspPreListDao);

        bisInspBasePresExtDao.insert(basePresExt);
        bisInspSafeExtManageDao.insert(safeExtManage);
        bisInspBaseViewDao.insert(baseView);
        bisInspBaseExtDao.insert(baseExt);
        this.insert(bisInspRsvrRgstr);
        return 1;
    }

    @Override
    public void updateRG(BisInspRsvrRgstr rsvrRgstr) {
        Date date = new Date();
        if (StatusEnum.START.getStatus().equals(rsvrRgstr.getResRunStat())) {
            BisInspSafeExtManage inspSafeExtManage = new BisInspSafeExtManage();
            inspSafeExtManage.setUpdateTime(date);
            inspSafeExtManage.setStatus(rsvrRgstr.getState());
            inspSafeExtManage.setRgstrId(rsvrRgstr.getRgstrId());
            bisInspSafeExtManageDao.updateBy(inspSafeExtManage);
        }
        BisInspBaseView inspBaseView = new BisInspBaseView();
        inspBaseView.setUpdateTime(date);
        inspBaseView.setStatus(rsvrRgstr.getState());
        inspBaseView.setRgstrId(rsvrRgstr.getRgstrId());
        bisInspBaseViewDao.updateBy(inspBaseView);
        if (StatusEnum.START.getStatus().equals(rsvrRgstr.getBaseStat())) {
            BisInspBaseExt inspBaseExt = new BisInspBaseExt();
            inspBaseExt.setUpdateTime(date);
            inspBaseExt.setStatus(rsvrRgstr.getState());
            inspBaseExt.setRgstrId(rsvrRgstr.getRgstrId());
            bisInspBaseExtDao.updateBy(inspBaseExt);
        }
        if (StatusEnum.START.getStatus().equals(rsvrRgstr.getPresStat())) {
            BisInspBasePresExt inspBasePresExt = new BisInspBasePresExt();
            inspBasePresExt.setUpdateTime(date);
            inspBasePresExt.setStatus(rsvrRgstr.getState());
            inspBasePresExt.setRgstrId(rsvrRgstr.getRgstrId());
            bisInspBasePresExtDao.updateBy(inspBasePresExt);
        }
        //提交督查表，更新问题状态
        BisInspPblm bisInspPblm = new BisInspPblm();
        bisInspPblm.setPblmStat("1");
        bisInspPblm.setRegid(rsvrRgstr.getRgstrId());
        if (StringUtils.isNotBlank(rsvrRgstr.getRgstrId())) {
            bisInspPblmDao.updatePblmStatus(bisInspPblm);
        }

        bisInspRsvrRgstrDao.update(rsvrRgstr);

    }


    @Override
    public PageInfo<BisInspRsvrRgstrDto> findPageByType(TypeParam typeParam) {
        if (StringUtils.isNotBlank(typeParam.getCode())) {
            typeParam.setCode(AdLevelUtil.SubAd(typeParam.getCode()).get(SplitValue.SUBAD).toString());
        }
        PageHelper.startPage(typeParam);
        List<BisInspRsvrRgstrDto> list = bisInspRsvrRgstrDao.findPageByType(typeParam);
        PageInfo<BisInspRsvrRgstrDto> pageInfo = new PageInfo(list);
        return pageInfo;
    }

    @Override
    public List<BisInspRsvrRgstrDto> findListByType(TypeParam typeParam) {
        if (StringUtils.isNotBlank(typeParam.getCode())) {
            typeParam.setCode(AdLevelUtil.SubAd(typeParam.getCode()).get(SplitValue.SUBAD).toString());
        }
        List<BisInspRsvrRgstrDto> list = bisInspRsvrRgstrDao.findPageByType(typeParam);
        if (list == null) {
            return new ArrayList<>();
        }
        return list;
    }

    @Autowired
    private AttRsBaseDao attRsBaseDao;

    @Override
    public PageInfo<AttRsBase> findAttBaseInfo(AttRsBaseParam attRsBaseParam) {
        PageHelper.startPage(attRsBaseParam);
        List<AttRsBase> list = attRsBaseDao.findList(attRsBaseParam);
        PageInfo<AttRsBase> pageInfo = new PageInfo(list);
        return pageInfo;
    }

    /**
     * 批量设置水库是否省属
     *
     * @param rsBaseParam
     * @return
     */
    @Override
    public int updateBatchProvincial(AttRsBaseParam rsBaseParam) {
        return attRsBaseDao.updateBatchProvincial(rsBaseParam);
    }

    /**
     * 根据水库的监控点编号获取到监控预览地址
     *
     * @param cameraIndexCode
     * @return
     */
    @Override
    public Map<String, Object> getMonitorVideoUrlByCameraIndexCode(String cameraIndexCode) {
        return HikvisionOpenApiUtil.callPostPreviewURLs(cameraIndexCode);
    }

    @Override
    public PageInfo<BisInspRsvrRgstrPcDto> findPcPage(TypeParam typeParam) {
        PageHelper.startPage(typeParam);
        List<BisInspRsvrRgstrPcDto> list = bisInspRsvrRgstrDao.findPcPage(typeParam);
        if (list.size() > 0) {
            for (BisInspRsvrRgstrPcDto b : list) {
                if (b.getAdFullName() != null) {
                    if (b.getAdFullName().contains(SplitValue.HENG_SPLIT)) {
                        String[] split = b.getAdFullName().split(SplitValue.HENG_SPLIT);
                        if (split.length == 3) {
                            b.setProvince(split[0]);
                            b.setCity(split[1]);
                            b.setCounty(split[2]);
                        }
                        if (split.length == 2) {
                            b.setProvince(split[0]);
                            b.setCity(split[1]);
                            b.setCounty("");
                        }
                    } else {
                        b.setProvince(b.getAdFullName());
                    }
                }
            }
        }
        return new PageInfo<>(list);
    }

    @Override
    public BisInspRsvrRgstr getByRsvrRgstr(BisInspRsvrRgstrParam inspRsvrRgstrParam) {
        String state = StateEnum.NOWASTSTATE.getKey();
        String persId = inspRsvrRgstrParam.getRecPersId();
        inspRsvrRgstrParam.setRecPersId("");
        BisInspRsvrRgstr bisInspRsvrRgstr = bisInspRsvrRgstrDao.getBy(inspRsvrRgstrParam);
        if (bisInspRsvrRgstr != null) {
            if (bisInspRsvrRgstr.getIntm() == null) {
                bisInspRsvrRgstr.setIntm(new Date());
                bisInspRsvrRgstrDao.update(bisInspRsvrRgstr);
            }
            return bisInspRsvrRgstr;
        }
        bisInspRsvrRgstr = new BisInspRsvrRgstr();
        AttRsBaseParam baseParam = new AttRsBaseParam();
        baseParam.setRsCode(inspRsvrRgstrParam.getRsCode());
        AttRsBase attRsBase = attRsBaseDao.getBy(baseParam);
        if (attRsBase == null) {
            return new BisInspRsvrRgstr();
        }
        bisInspRsvrRgstr.setRgstrId(UuidUtil.uuid());
        bisInspRsvrRgstr.setAdCode(attRsBase.getAdmDiv());
        bisInspRsvrRgstr.setRsvrAdmName(attRsBase.getRsAdmName());
        if (attRsBase.getDamSizeHig() == null) {
            bisInspRsvrRgstr.setDamMaxHigh(null);
        } else {
            bisInspRsvrRgstr.setDamMaxHigh(Double.toString(attRsBase.getDamSizeHig()));
        }

        bisInspRsvrRgstr.setDamType(attRsBase.getDamType());
        bisInspRsvrRgstr.setDamRegCode(attRsBase.getRegCode());
        bisInspRsvrRgstr.setEngScal(attRsBase.getEngScal());
        bisInspRsvrRgstr.setObjId(inspRsvrRgstrParam.getObjId());
        bisInspRsvrRgstr.setHystSite(attRsBase.getRsLoc());
        bisInspRsvrRgstr.setLocation(attRsBase.getLocation());
        bisInspRsvrRgstr.setState(state);
        bisInspRsvrRgstr.setRsCode(inspRsvrRgstrParam.getRsCode());
        bisInspRsvrRgstr.setTotCap(attRsBase.getTotCap());
        if (attRsBase.getCenterYGd() != null) {
            bisInspRsvrRgstr.setRsvrLat(Double.parseDouble(attRsBase.getCenterYGd()));
        }
        if (attRsBase.getCenterXGd() != null) {
            bisInspRsvrRgstr.setRsvrLong(Double.parseDouble(attRsBase.getCenterXGd()));
        }
        bisInspRsvrRgstr.setDataStat(state);
        Date date = new Date();
        bisInspRsvrRgstr.setIntm(date);
        bisInspRsvrRgstr.setUptm(date);
        bisInspRsvrRgstr.setPresStat(state);
        bisInspRsvrRgstr.setRecPersId(persId);
        bisInspRsvrRgstr.setResCreateTime(attRsBase.getCompDate());
        bisInspRsvrRgstr.setHasDamRegCode("1");
        bisInspRsvrRgstr.setCompDateStr(attRsBase.getCompDateStr());
        bisInspRsvrRgstr.setViewStat(state);
        bisInspRsvrRgstr.setRsvrNm(attRsBase.getRsName());
        bisInspRsvrRgstr.setBaseStat(state);
        bisInspRsvrRgstr.setReverStat(state);
        bisInspRsvrRgstr.setResRunStat(state);
        bisInspRsvrRgstr.setIsSaf(attRsBase.getIsSaf());
        bisInspRsvrRgstr.setIsAction(attRsBase.getIsAction());
        bisInspRsvrRgstr.setInspType(attRsBase.getInspType());
        this.insert(bisInspRsvrRgstr);
        return bisInspRsvrRgstr;
    }

    @Override
    public int insert(BisInspRsvrRgstr b) {
        int ret = 1;
        String objId = b.getObjId();
        BisInspRsvrRgstrParam bisInspRsvrRgstrParam = new BisInspRsvrRgstrParam();
        bisInspRsvrRgstrParam.setObjId(objId);
        List<BisInspRsvrRgstr> list = bisInspRsvrRgstrDao.findList(bisInspRsvrRgstrParam);
        if (list == null || list.size() == 0) {
            ret = bisInspRsvrRgstrDao.insert(b);
        }
        return ret;
    }

    /**
     * 四川省 编辑水库的注册登记号
     *
     * @param inspPblmPlist
     * @return
     */
    @Override
    public int updateRsvrDamRegCode(BisInspPblmPlist inspPblmPlist) {
        int rows = 0;
        // 更新整改问题的注册登记号
        BisInspPblmPlist updateItem = new BisInspPblmPlist();
        updateItem.setId(inspPblmPlist.getId());
        updateItem.setDamRegCode(inspPblmPlist.getDamRegCode());
        Date curDate = new Date();
        updateItem.setUptm(curDate);
        rows = this.bisInspPblmPlistDao.update(updateItem);
        // 更新登记表中的 注册登记号
        List<BisInspRsvrRgstr> rgstrList = this.bisInspRsvrRgstrDao.getByPblmId(inspPblmPlist.getPblmId());
        if (null != rgstrList && rgstrList.size() > 0) {
            BisInspRsvrRgstr bisInspRsvrRgstr = new BisInspRsvrRgstr();
            bisInspRsvrRgstr.setUptm(curDate);
            BisInspRsvrRgstr item = rgstrList.get(0);
            String rsCode = item.getRsCode();
            if (StringUtils.isNotEmpty(rsCode)) {
                bisInspRsvrRgstr.setRsCode(rsCode);
                bisInspRsvrRgstr.setDamRegCode(inspPblmPlist.getDamRegCode());
                // 更新水库登记表中的注册登记号 把此水库的所有注册登记表都更新
                rows = this.bisInspRsvrRgstrDao.updateDamRegCodeByRsCode(bisInspRsvrRgstr);
                // 更新水库的所有整改问题的注册登记号
                updateItem.setId(null);
                updateItem.setObjCode(rsCode);
                this.bisInspPblmPlistDao.updateDamRegCodeByRsCode(updateItem);
            }
            // 更新基础表中的大坝注册登记号
            BisInspAllObj inspAllObj = this.bisInspAllObjDao.get(item.getObjId());
            if (null != inspAllObj && StringUtils.isNotEmpty(inspAllObj.getCode())) {
                AttRsBase attRsBase = new AttRsBase();
                attRsBase.setRegCode(bisInspRsvrRgstr.getDamRegCode());
                attRsBase.setRsCode(inspAllObj.getCode());
                attRsBase.setUptm(curDate);
                this.attRsBaseDao.updateRegCodeByCode(attRsBase);
            }
        }
        return rows;
    }


}